Bump isl to isl-0.18-768-g033b61ae

[maxf]

Summary

This is a general maintenance update

[grosser]

isl commit 033b61ae3 should have fixed the regression I pointed out.

[maxf]

Update isl to isl-0.18-768-g033b61ae which includes an additional regression fix.

[maxf]

Hi Tobias,

thanks for the additional check. I used the option and verified that isl as of 033b61ae3 indeed fixes the issue.
D34971 should take care of the other regression I observed using LNT, afterwards, this should be ready to land.
Best,

Maximilian

polly/trunk/lib/External/isl/GIT_HEAD_ID

-isl-0.18-679-g6e75a0d
+isl-0.18-768-g033b61ae

polly/trunk/lib/External/isl/Makefile.am

 if HAVE_CLANG
     MAYBE_INTERFACE = interface
 endif
 SUBDIRS = . $(MAYBE_INTERFACE) doc
 DIST_SUBDIRS = $(MAYBE_INTERFACE) doc
 
 ACLOCAL_AMFLAGS = -I m4
 AUTOMAKE_OPTIONS = nostdinc subdir-objects
 
 lib_LTLIBRARIES = libisl.la
 noinst_PROGRAMS = isl_test isl_polyhedron_sample isl_pip \
   isl_polyhedron_minimize isl_polytope_scan \
   isl_polyhedron_detect_equalities isl_cat \
-  isl_closure isl_bound isl_schedule isl_codegen isl_test_int
-TESTS = isl_test codegen_test.sh pip_test.sh bound_test.sh isl_test_int
+  isl_closure isl_bound isl_schedule isl_codegen isl_test_int \
+  isl_flow isl_flow_cmp
+TESTS = isl_test codegen_test.sh pip_test.sh bound_test.sh isl_test_int \
+  flow_test.sh
 
 if IMATH_FOR_MP
 
 MP_SRC = \
   isl_hide_deprecated.h \
   isl_imath.c \
   isl_imath.h \
   isl_int_imath.h \
libisl_la_SOURCES = \
   isl_tab.c \
   isl_tab.h \
   isl_tab_pip.c \
   isl_tarjan.c \
   isl_tarjan.h \
   isl_transitive_closure.c \
   isl_union_map.c \
   isl_union_map_private.h \
+  isl_union_set_private.h \
   isl_val.c \
   isl_val_private.h \
   isl_vec_private.h \
   isl_vec.c \
   isl_version.c \
   isl_vertices_private.h \
   isl_vertices.c \
   isl_yaml.h

 isl_pip_SOURCES = \
   pip.c
 
 isl_schedule_LDFLAGS = @MP_LDFLAGS@
 isl_schedule_LDADD = libisl.la @MP_LIBS@
 isl_schedule_SOURCES = \
   schedule.c
 
+isl_flow_LDFLAGS = @MP_LDFLAGS@
+isl_flow_LDADD = libisl.la @MP_LIBS@
+isl_flow_SOURCES = \
+  flow.c
+
+isl_flow_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_flow_cmp_LDADD = libisl.la @MP_LIBS@
+isl_flow_cmp_SOURCES = \
+  flow_cmp.c
+
 isl_codegen_LDFLAGS = @MP_LDFLAGS@
 isl_codegen_LDADD = libisl.la @MP_LIBS@
 isl_codegen_SOURCES = \
   codegen.c
 
 isl_bound_LDFLAGS = @MP_LDFLAGS@
 isl_bound_LDADD = libisl.la @MP_LIBS@
 isl_bound_SOURCES = \
DISTCLEANFILES = \
   include/isl/stdint.h
 
 EXTRA_DIST = \
   LICENSE \
   isl_config_post.h \
   basis_reduction_templ.c \
   bset_to_bmap.c \
   bset_from_bmap.c \
+  extract_key.c \
   isl_list_templ.c \
   isl_list_templ.h \
   isl_map_lexopt_templ.c \
+  isl_maybe_map.h \
   isl_multi_macro.h \
   isl_multi_templ.c \
   isl_multi_templ.h \
   isl_multi_apply_templ.c \
   isl_multi_apply_set.c \
   isl_multi_apply_union_set.c \
   isl_multi_cmp.c \
   isl_multi_coalesce.c \

polly/trunk/lib/External/isl/Makefile.in

 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 noinst_PROGRAMS = isl_test$(EXEEXT) isl_polyhedron_sample$(EXEEXT) \
   isl_pip$(EXEEXT) isl_polyhedron_minimize$(EXEEXT) \
   isl_polytope_scan$(EXEEXT) \
   isl_polyhedron_detect_equalities$(EXEEXT) isl_cat$(EXEEXT) \
   isl_closure$(EXEEXT) isl_bound$(EXEEXT) isl_schedule$(EXEEXT) \
-  isl_codegen$(EXEEXT) isl_test_int$(EXEEXT) $(am__EXEEXT_1)
+  isl_codegen$(EXEEXT) isl_test_int$(EXEEXT) isl_flow$(EXEEXT) \
+  isl_flow_cmp$(EXEEXT) $(am__EXEEXT_1)
 TESTS = isl_test$(EXEEXT) codegen_test.sh pip_test.sh bound_test.sh \
-  isl_test_int$(EXEEXT) $(am__EXEEXT_1)
+  isl_test_int$(EXEEXT) flow_test.sh $(am__EXEEXT_1)
 @IMATH_FOR_MP_TRUE@am__append_1 = isl_test_imath
 @IMATH_FOR_MP_TRUE@am__append_2 = isl_test_imath
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@am__append_3 = isl_int_sioimath.h \
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@ isl_int_sioimath.c \
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@ isl_val_sioimath.c
 
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@am__append_4 = isl_val_imath.c
 subdir = .

 DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
   $(am__configure_deps) $(deprecated_HEADERS) \
   $(am__pkginclude_HEADERS_DIST) $(am__DIST_COMMON)
 am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
  configure.lineno config.status.lineno
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = isl_config.h
 CONFIG_CLEAN_FILES = isl_srcdir.c bound_test.sh codegen_test.sh \
-  pip_test.sh
+  pip_test.sh flow_test.sh
 CONFIG_CLEAN_VPATH_FILES =
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     *) f=$$p;; \
   esac;
 am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
 am__install_max = 40
am__libisl_la_SOURCES_DIST = mp_get_memory_functions.c isl_int_gmp.h \
   isl_schedule_node_private.h isl_schedule_read.c \
   isl_schedule_tree.c isl_schedule_tree.h isl_schedule_private.h \
   isl_schedule_constraints.c isl_schedule_constraints.h \
   isl_scheduler.c isl_set_list.c isl_sort.c isl_sort.h \
   isl_space.c isl_space_private.h isl_stream.c \
   isl_stream_private.h isl_seq.c isl_seq.h isl_tab.c isl_tab.h \
   isl_tab_pip.c isl_tarjan.c isl_tarjan.h \
   isl_transitive_closure.c isl_union_map.c \
-  isl_union_map_private.h isl_val.c isl_val_private.h \
-  isl_vec_private.h isl_vec.c isl_version.c \
+  isl_union_map_private.h isl_union_set_private.h isl_val.c \
+  isl_val_private.h isl_vec_private.h isl_vec.c isl_version.c \
   isl_vertices_private.h isl_vertices.c isl_yaml.h
 @GMP_FOR_MP_TRUE@@NEED_GET_MEMORY_FUNCTIONS_TRUE@am__objects_1 = mp_get_memory_functions.lo
 am__dirstamp = $(am__leading_dot)dirstamp
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@am__objects_2 =  \
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@ isl_int_sioimath.lo \
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@ isl_val_sioimath.lo
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@am__objects_3 =  \
 @IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@  isl_val_imath.lo

 isl_closure_OBJECTS = $(am_isl_closure_OBJECTS)
 isl_closure_DEPENDENCIES = libisl.la
 am_isl_codegen_OBJECTS = codegen.$(OBJEXT)
 isl_codegen_OBJECTS = $(am_isl_codegen_OBJECTS)
 isl_codegen_DEPENDENCIES = libisl.la
 isl_codegen_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
   $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
   $(isl_codegen_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_flow_OBJECTS = flow.$(OBJEXT)
+isl_flow_OBJECTS = $(am_isl_flow_OBJECTS)
+isl_flow_DEPENDENCIES = libisl.la
+isl_flow_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+  $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+  $(isl_flow_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_flow_cmp_OBJECTS = flow_cmp.$(OBJEXT)
+isl_flow_cmp_OBJECTS = $(am_isl_flow_cmp_OBJECTS)
+isl_flow_cmp_DEPENDENCIES = libisl.la
+isl_flow_cmp_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+  $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+  $(isl_flow_cmp_LDFLAGS) $(LDFLAGS) -o $@
 am_isl_pip_OBJECTS = pip.$(OBJEXT)
 isl_pip_OBJECTS = $(am_isl_pip_OBJECTS)
 isl_pip_DEPENDENCIES = libisl.la
 isl_pip_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
   $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
   $(isl_pip_LDFLAGS) $(LDFLAGS) -o $@
 am_isl_polyhedron_detect_equalities_OBJECTS =  \
   polyhedron_detect_equalities.$(OBJEXT)
LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
   $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
   $(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 SOURCES = $(libisl_la_SOURCES) $(isl_bound_SOURCES) $(isl_cat_SOURCES) \
   $(isl_closure_SOURCES) $(isl_codegen_SOURCES) \
-  $(isl_pip_SOURCES) $(isl_polyhedron_detect_equalities_SOURCES) \
+  $(isl_flow_SOURCES) $(isl_flow_cmp_SOURCES) $(isl_pip_SOURCES) \
+  $(isl_polyhedron_detect_equalities_SOURCES) \
   $(isl_polyhedron_minimize_SOURCES) \
   $(isl_polyhedron_sample_SOURCES) $(isl_polytope_scan_SOURCES) \
   $(isl_schedule_SOURCES) isl_test.c isl_test_imath.c \
   isl_test_int.c
 DIST_SOURCES = $(am__libisl_la_SOURCES_DIST) $(isl_bound_SOURCES) \
   $(isl_cat_SOURCES) $(isl_closure_SOURCES) \
-  $(isl_codegen_SOURCES) $(isl_pip_SOURCES) \
+  $(isl_codegen_SOURCES) $(isl_flow_SOURCES) \
+  $(isl_flow_cmp_SOURCES) $(isl_pip_SOURCES) \
   $(isl_polyhedron_detect_equalities_SOURCES) \
   $(isl_polyhedron_minimize_SOURCES) \
   $(isl_polyhedron_sample_SOURCES) $(isl_polytope_scan_SOURCES) \
   $(isl_schedule_SOURCES) isl_test.c isl_test_imath.c \
   isl_test_int.c
 RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
   ctags-recursive dvi-recursive html-recursive info-recursive \
   install-data-recursive install-dvi-recursive \
am__set_b = \
   esac
 am__test_logs1 = $(TESTS:=.log)
 am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
 TEST_LOGS = $(am__test_logs2:.test.log=.log)
 TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
 TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
   $(TEST_LOG_FLAGS)
 am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/bound_test.sh.in \
-  $(srcdir)/codegen_test.sh.in $(srcdir)/isl_config.h.in \
-  $(srcdir)/isl_srcdir.c.in $(srcdir)/pip_test.sh.in AUTHORS \
-  ChangeLog README compile config.guess config.sub depcomp \
-  install-sh ltmain.sh missing test-driver
+  $(srcdir)/codegen_test.sh.in $(srcdir)/flow_test.sh.in \
+  $(srcdir)/isl_config.h.in $(srcdir)/isl_srcdir.c.in \
+  $(srcdir)/pip_test.sh.in AUTHORS ChangeLog README compile \
+  config.guess config.sub depcomp install-sh ltmain.sh missing \
+  test-driver
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
 am__remove_distdir = \
   if test -d "$(distdir)"; then \
     find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
       && rm -rf "$(distdir)" \
       || { sleep 5 && rm -rf "$(distdir)"; }; \
libisl_la_SOURCES = \
   isl_tab.c \
   isl_tab.h \
   isl_tab_pip.c \
   isl_tarjan.c \
   isl_tarjan.h \
   isl_transitive_closure.c \
   isl_union_map.c \
   isl_union_map_private.h \
+  isl_union_set_private.h \
   isl_val.c \
   isl_val_private.h \
   isl_vec_private.h \
   isl_vec.c \
   isl_version.c \
   isl_vertices_private.h \
   isl_vertices.c \
   isl_yaml.h

 isl_pip_SOURCES = \
   pip.c
 
 isl_schedule_LDFLAGS = @MP_LDFLAGS@
 isl_schedule_LDADD = libisl.la @MP_LIBS@
 isl_schedule_SOURCES = \
   schedule.c
 
+isl_flow_LDFLAGS = @MP_LDFLAGS@
+isl_flow_LDADD = libisl.la @MP_LIBS@
+isl_flow_SOURCES = \
+  flow.c
+
+isl_flow_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_flow_cmp_LDADD = libisl.la @MP_LIBS@
+isl_flow_cmp_SOURCES = \
+  flow_cmp.c
+
 isl_codegen_LDFLAGS = @MP_LDFLAGS@
 isl_codegen_LDADD = libisl.la @MP_LIBS@
 isl_codegen_SOURCES = \
   codegen.c
 
 isl_bound_LDFLAGS = @MP_LDFLAGS@
 isl_bound_LDADD = libisl.la @MP_LIBS@
 isl_bound_SOURCES = \
DISTCLEANFILES = \
   include/isl/stdint.h
 
 EXTRA_DIST = \
   LICENSE \
   isl_config_post.h \
   basis_reduction_templ.c \
   bset_to_bmap.c \
   bset_from_bmap.c \
+  extract_key.c \
   isl_list_templ.c \
   isl_list_templ.h \
   isl_map_lexopt_templ.c \
+  isl_maybe_map.h \
   isl_multi_macro.h \
   isl_multi_templ.c \
   isl_multi_templ.h \
   isl_multi_apply_templ.c \
   isl_multi_apply_set.c \
   isl_multi_apply_union_set.c \
   isl_multi_cmp.c \
   isl_multi_coalesce.c \

 isl_srcdir.c: $(top_builddir)/config.status $(srcdir)/isl_srcdir.c.in
   cd $(top_builddir) && $(SHELL) ./config.status $@
 bound_test.sh: $(top_builddir)/config.status $(srcdir)/bound_test.sh.in
   cd $(top_builddir) && $(SHELL) ./config.status $@
 codegen_test.sh: $(top_builddir)/config.status $(srcdir)/codegen_test.sh.in
   cd $(top_builddir) && $(SHELL) ./config.status $@
 pip_test.sh: $(top_builddir)/config.status $(srcdir)/pip_test.sh.in
   cd $(top_builddir) && $(SHELL) ./config.status $@
+flow_test.sh: $(top_builddir)/config.status $(srcdir)/flow_test.sh.in
+  cd $(top_builddir) && $(SHELL) ./config.status $@
 
 install-libLTLIBRARIES: $(lib_LTLIBRARIES)
   @$(NORMAL_INSTALL)
   @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
   list2=; for p in $$list; do \
     if test -f $$p; then \
       list2="$$list2 $$p"; \
     else :; fi; \

 isl_closure$(EXEEXT): $(isl_closure_OBJECTS) $(isl_closure_DEPENDENCIES) $(EXTRA_isl_closure_DEPENDENCIES) 
   @rm -f isl_closure$(EXEEXT)
   $(AM_V_CCLD)$(LINK) $(isl_closure_OBJECTS) $(isl_closure_LDADD) $(LIBS)
 
 isl_codegen$(EXEEXT): $(isl_codegen_OBJECTS) $(isl_codegen_DEPENDENCIES) $(EXTRA_isl_codegen_DEPENDENCIES) 
   @rm -f isl_codegen$(EXEEXT)
   $(AM_V_CCLD)$(isl_codegen_LINK) $(isl_codegen_OBJECTS) $(isl_codegen_LDADD) $(LIBS)
 
+isl_flow$(EXEEXT): $(isl_flow_OBJECTS) $(isl_flow_DEPENDENCIES) $(EXTRA_isl_flow_DEPENDENCIES) 
+  @rm -f isl_flow$(EXEEXT)
+  $(AM_V_CCLD)$(isl_flow_LINK) $(isl_flow_OBJECTS) $(isl_flow_LDADD) $(LIBS)
+
+isl_flow_cmp$(EXEEXT): $(isl_flow_cmp_OBJECTS) $(isl_flow_cmp_DEPENDENCIES) $(EXTRA_isl_flow_cmp_DEPENDENCIES) 
+  @rm -f isl_flow_cmp$(EXEEXT)
+  $(AM_V_CCLD)$(isl_flow_cmp_LINK) $(isl_flow_cmp_OBJECTS) $(isl_flow_cmp_LDADD) $(LIBS)
+
 isl_pip$(EXEEXT): $(isl_pip_OBJECTS) $(isl_pip_DEPENDENCIES) $(EXTRA_isl_pip_DEPENDENCIES) 
   @rm -f isl_pip$(EXEEXT)
   $(AM_V_CCLD)$(isl_pip_LINK) $(isl_pip_OBJECTS) $(isl_pip_LDADD) $(LIBS)
 
 isl_polyhedron_detect_equalities$(EXEEXT): $(isl_polyhedron_detect_equalities_OBJECTS) $(isl_polyhedron_detect_equalities_DEPENDENCIES) $(EXTRA_isl_polyhedron_detect_equalities_DEPENDENCIES) 
   @rm -f isl_polyhedron_detect_equalities$(EXEEXT)
   $(AM_V_CCLD)$(LINK) $(isl_polyhedron_detect_equalities_OBJECTS) $(isl_polyhedron_detect_equalities_LDADD) $(LIBS)
 

 distclean-compile:
   -rm -f *.tab.c
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/basis_reduction_tab.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bound.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cat.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/codegen.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flow.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flow_cmp.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_aff.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_affine_hull.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_arg.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build_expr.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_codegen.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_graft.Plo@am__quote@
bound_test.sh.log: bound_test.sh
   "$$tst" $(AM_TESTS_FD_REDIRECT)
 isl_test_int.log: isl_test_int$(EXEEXT)
   @p='isl_test_int$(EXEEXT)'; \
   b='isl_test_int'; \
   $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
   --log-file $$b.log --trs-file $$b.trs \
   $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
   "$$tst" $(AM_TESTS_FD_REDIRECT)
+flow_test.sh.log: flow_test.sh
+  @p='flow_test.sh'; \
+  b='flow_test.sh'; \
+  $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+  --log-file $$b.log --trs-file $$b.trs \
+  $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+  "$$tst" $(AM_TESTS_FD_REDIRECT)
 isl_test_imath.log: isl_test_imath$(EXEEXT)
   @p='isl_test_imath$(EXEEXT)'; \
   b='isl_test_imath'; \
   $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
   --log-file $$b.log --trs-file $$b.trs \
   $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
   "$$tst" $(AM_TESTS_FD_REDIRECT)
 .test.log:

polly/trunk/lib/External/isl/config.guess

 #! /bin/sh
 # Attempt to guess a canonical system name.
 #   Copyright 1992-2016 Free Software Foundation, Inc.
 
-timestamp='2016-04-02'
+timestamp='2016-10-02'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of
case "${UNAME_MACHINE_ARCH}" in
       earmv*)
     arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
     endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
     machine=${arch}${endian}-unknown
     ;;
       *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
   esac
   # The Operating System including object format, if it has switched
-  # to ELF recently, or will in the future.
+  # to ELF recently (or will in the future) and ABI.
   case "${UNAME_MACHINE_ARCH}" in
-      arm*|earm*|i386|m68k|ns32k|sh3*|sparc|vax)
+      earm*)
+    os=netbsdelf
+    ;;
+      arm*|i386|m68k|ns32k|sh3*|sparc|vax)
     eval $set_cc_for_build
     if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
       | grep -q __ELF__
     then
         # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
         # Return netbsd for either.  FIX?
         os=netbsd
     else
EOF
   #else
   CPU=
   #endif
   #endif
 EOF
   eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
   test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
   ;;
+    mips64el:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+  exit ;;
     openrisc*:Linux:*:*)
   echo or1k-unknown-linux-${LIBC}
   exit ;;
     or32:Linux:*:* | or1k*:Linux:*:*)
   echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
   exit ;;
     padre:Linux:*:*)
   echo sparc-unknown-linux-${LIBC}
EOF
   echo powerpc-unknown-linux-${LIBC}
   exit ;;
     ppc64le:Linux:*:*)
   echo powerpc64le-unknown-linux-${LIBC}
   exit ;;
     ppcle:Linux:*:*)
   echo powerpcle-unknown-linux-${LIBC}
   exit ;;
+    riscv32:Linux:*:* | riscv64:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+  exit ;;
     s390:Linux:*:* | s390x:Linux:*:*)
   echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
   exit ;;
     sh64*:Linux:*:*)
   echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
   exit ;;
     sh*:Linux:*:*)
   echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
     amd64:Isilon\ OneFS:*:*)
   echo x86_64-unknown-onefs
   exit ;;
 esac
 
 cat >&2 <<EOF
 $0: unable to guess system type
 
-This script, last modified $timestamp, has failed to recognize
-the operating system you are using. It is advised that you
-download the most up to date version of the config scripts from
+This script (version $timestamp), has failed to recognize the
+operating system you are using. If your script is old, overwrite
+config.guess and config.sub with the latest versions from:
 
   http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
 and
   http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
 
-If the version you run ($0) is already up to date, please
-send the following data and any information you think might be
-pertinent to <[e-mail]> in order to provide the needed
-information to handle your system.
+If $0 has already been updated, send the following data and any
+information you think might be pertinent to [e-mail] to
+provide the necessary information to handle your system.
 
 config.guess timestamp = $timestamp
 
 uname -m = `(uname -m) 2>/dev/null || echo unknown`
 uname -r = `(uname -r) 2>/dev/null || echo unknown`
 uname -s = `(uname -s) 2>/dev/null || echo unknown`
 uname -v = `(uname -v) 2>/dev/null || echo unknown`
 

polly/trunk/lib/External/isl/config.sub

 #! /bin/sh
 # Configuration validation subroutine script.
 #   Copyright 1992-2016 Free Software Foundation, Inc.
 
-timestamp='2016-03-30'
+timestamp='2016-11-04'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of

 
 # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
   nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
   linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
   knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | \
+  kopensolaris*-gnu* | cloudabi*-eabi* | \
   storm-chaos* | os2-emx* | rtmk-nova*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
   android-linux)
     os=-linux-android
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
     ;;
case $basic_machine in
   | mt \
   | msp430 \
   | nds32 | nds32le | nds32be \
   | nios | nios2 | nios2eb | nios2el \
   | ns16k | ns32k \
   | open8 | or1k | or1knd | or32 \
   | pdp10 | pdp11 | pj | pjl \
   | powerpc | powerpc64 | powerpc64le | powerpcle \
+  | pru \
   | pyramid \
   | riscv32 | riscv64 \
   | rl78 | rx \
   | score \
   | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
   | sh64 | sh64le \
   | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
   | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
case $basic_machine in
   | nds32-* | nds32le-* | nds32be-* \
   | nios-* | nios2-* | nios2eb-* | nios2el-* \
   | none-* | np1-* | ns16k-* | ns32k-* \
   | open8-* \
   | or1k*-* \
   | orion-* \
   | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
   | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+  | pru-* \
   | pyramid-* \
   | riscv32-* | riscv64-* \
   | rl78-* | romp-* | rs6000-* | rx-* \
   | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
   | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
   | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
   | sparclite-* \
   | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
case $basic_machine in
   dpx20 | dpx20-*)
     basic_machine=rs6000-bull
     os=-bosx
     ;;
   dpx2* | dpx2*-bull)
     basic_machine=m68k-bull
     os=-sysv3
     ;;
+  e500v[12])
+    basic_machine=powerpc-unknown
+    os=$os"spe"
+    ;;
+  e500v[12]-*)
+    basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=$os"spe"
+    ;;
   ebmon29k)
     basic_machine=a29k-amd
     os=-ebmon
     ;;
   elxsi)
     basic_machine=elxsi-elxsi
     os=-bsd
     ;;
pn)
     ;;
   power)  basic_machine=power-ibm
     ;;
   ppc | ppcbe)  basic_machine=powerpc-unknown
     ;;
   ppc-* | ppcbe-*)
     basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
     ;;
-  ppcle | powerpclittle | ppc-le | powerpc-little)
+  ppcle | powerpclittle)
     basic_machine=powerpcle-unknown
     ;;
   ppcle-* | powerpclittle-*)
     basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
     ;;
   ppc64)  basic_machine=powerpc64-unknown
     ;;
   ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
     ;;
-  ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+  ppc64le | powerpc64little)
     basic_machine=powerpc64le-unknown
     ;;
   ppc64le-* | powerpc64little-*)
     basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
     ;;
   ps2)
     basic_machine=i386-ibm
     ;;
-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
         | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
         | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
         | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
         | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
         | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
         | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
         | -chorusos* | -chorusrdb* | -cegcc* \
         | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-        | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+        | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
         | -linux-newlib* | -linux-musl* | -linux-uclibc* \
         | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
         | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
         | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
         | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
         | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
         | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
         | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
         | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-        | -onefs* | -tirtos*)
+        | -onefs* | -tirtos* | -phoenix* | -fuchsia*)
   # Remember, each alternative MUST END IN *, to match a version number.
     ;;
   -qnx*)
     case $basic_machine in
         x86-* | i*86-*)
       ;;
         *)
       os=-nto$os

polly/trunk/lib/External/isl/configure

 
 $as_echo "#define initializeBuiltins InitializeBuiltins" >>confdefs.h
 
 fi
 rm -f conftest*
 
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+#include <clang/Frontend/FrontendOptions.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "IK_C" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define IK_C InputKind::C" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
   #include <clang/Basic/TargetOptions.h>
   #include <clang/Lex/PreprocessorOptions.h>
   #include <clang/Frontend/CompilerInstance.h>
 
 int
 main ()
 {

 
 fi
 ac_config_files="$ac_config_files bound_test.sh"
 
 ac_config_files="$ac_config_files codegen_test.sh"
 
 ac_config_files="$ac_config_files pip_test.sh"
 
+ac_config_files="$ac_config_files flow_test.sh"
+
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
 # tests run on this system so they can be shared between configure
 # scripts and configure runs, see configure's option --config-cache.
 # It is not useful on other systems.  If it contains results you don't
 # want to keep, you may remove or edit it.
 #
case $ac_config_target in
     "isl_config.h") CONFIG_HEADERS="$CONFIG_HEADERS isl_config.h" ;;
     "isl_srcdir.c") CONFIG_FILES="$CONFIG_FILES isl_srcdir.c" ;;
     "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
     "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
     "interface/Makefile") CONFIG_FILES="$CONFIG_FILES interface/Makefile" ;;
     "bound_test.sh") CONFIG_FILES="$CONFIG_FILES bound_test.sh" ;;
     "codegen_test.sh") CONFIG_FILES="$CONFIG_FILES codegen_test.sh" ;;
     "pip_test.sh") CONFIG_FILES="$CONFIG_FILES pip_test.sh" ;;
+    "flow_test.sh") CONFIG_FILES="$CONFIG_FILES flow_test.sh" ;;
 
   *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
 done
 
 
 # If the user did not use the arguments to specify the items to instantiate,
 # then the envvar interface is used.  Set only those that are not.

 sed -f conftest.sed  $pkgconfig_generate.in > $pkgconfig_uninstalled
 if test ! -s $pkgconfig_uninstalled ; then
     as_fn_error $? "$pkgconfig_uninstalled is empty" "$LINENO" 5
 fi ; rm conftest.sed # DONE generate $pkgconfig_uninstalled
  ;;
     "bound_test.sh":F) chmod +x bound_test.sh ;;
     "codegen_test.sh":F) chmod +x codegen_test.sh ;;
     "pip_test.sh":F) chmod +x pip_test.sh ;;
+    "flow_test.sh":F) chmod +x flow_test.sh ;;
 
   esac
 done # for ac_tag
 
 
 as_fn_exit 0
 _ACEOF
 ac_clean_files=$ac_clean_files_save

polly/trunk/lib/External/isl/configure.ac

 AC_CONFIG_FILES(Makefile)
 AC_CONFIG_FILES(doc/Makefile)
 if test $with_clang = system; then
   AC_CONFIG_FILES(interface/Makefile)
 fi
 AC_CONFIG_FILES([bound_test.sh], [chmod +x bound_test.sh])
 AC_CONFIG_FILES([codegen_test.sh], [chmod +x codegen_test.sh])
 AC_CONFIG_FILES([pip_test.sh], [chmod +x pip_test.sh])
+AC_CONFIG_FILES([flow_test.sh], [chmod +x flow_test.sh])
 AC_CONFIG_COMMANDS_POST([
   dnl pass on arguments to subdir configures, but don't
   dnl add them to config.status
   ac_configure_args="$ac_configure_args $isl_configure_args"
 ])
 AC_OUTPUT

polly/trunk/lib/External/isl/doc/user.pod

The following binary operations are available on C<isl_val>s.
   __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
     unsigned long v2);
   __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
     __isl_take isl_val *v2);
   __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
     unsigned long v2);
   __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
     __isl_take isl_val *v2);
+  __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
+    unsigned long v2);
 
 On integer values, we additionally have the following operations.
 
   #include <isl/val.h>
   __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
   __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
     __isl_take isl_val *v2);
   __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
     __isl_take isl_pw_qpolynomial *pwqp,
     enum isl_dim_type type, unsigned n,
     __isl_take isl_val *v);
 
 Intersect the set, relation or function domain
 with the hyperplane where the given
 dimension has the fixed given value.
 
-  __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
-    __isl_take isl_basic_map *bmap,
-    enum isl_dim_type type, unsigned pos, int value);
-  __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
-    __isl_take isl_basic_map *bmap,
-    enum isl_dim_type type, unsigned pos, int value);
+  #include <isl/set.h>
+  __isl_give isl_basic_set *
+  isl_basic_set_lower_bound_val(
+    __isl_take isl_basic_set *bset,
+    enum isl_dim_type type, unsigned pos,
+    __isl_take isl_val *value);
+  __isl_give isl_basic_set *
+  isl_basic_set_upper_bound_val(
+    __isl_take isl_basic_set *bset,
+    enum isl_dim_type type, unsigned pos,
+    __isl_take isl_val *value);
   __isl_give isl_set *isl_set_lower_bound_si(
     __isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos, int value);
   __isl_give isl_set *isl_set_lower_bound_val(
     __isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos,
     __isl_take isl_val *value);
-  __isl_give isl_map *isl_map_lower_bound_si(
-    __isl_take isl_map *map,
-    enum isl_dim_type type, unsigned pos, int value);
   __isl_give isl_set *isl_set_upper_bound_si(
     __isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos, int value);
   __isl_give isl_set *isl_set_upper_bound_val(
     __isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos,
     __isl_take isl_val *value);
+
+  #include <isl/map.h>
+  __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
+    __isl_take isl_basic_map *bmap,
+    enum isl_dim_type type, unsigned pos, int value);
+  __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
+    __isl_take isl_basic_map *bmap,
+    enum isl_dim_type type, unsigned pos, int value);
+  __isl_give isl_map *isl_map_lower_bound_si(
+    __isl_take isl_map *map,
+    enum isl_dim_type type, unsigned pos, int value);
   __isl_give isl_map *isl_map_upper_bound_si(
     __isl_take isl_map *map,
     enum isl_dim_type type, unsigned pos, int value);
 
 Intersect the set or relation with the half-space where the given
 dimension has a value bounded by the fixed given integer value.
 
   __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
__isl_give isl_map *isl_map_intersect_domain(
     __isl_take isl_map *map,
     __isl_take isl_set *set);
   __isl_give isl_map *isl_map_intersect_range(
     __isl_take isl_map *map,
     __isl_take isl_set *set);
   __isl_give isl_map *isl_map_intersect(
     __isl_take isl_map *map1,
     __isl_take isl_map *map2);
+  __isl_give isl_map *
+  isl_map_intersect_domain_factor_range(
+    __isl_take isl_map *map,
+    __isl_take isl_map *factor);
+  __isl_give isl_map *
+  isl_map_intersect_range_factor_range(
+    __isl_take isl_map *map,
+    __isl_take isl_map *factor);
 
   #include <isl/union_set.h>
   __isl_give isl_union_set *isl_union_set_intersect_params(
     __isl_take isl_union_set *uset,
     __isl_take isl_set *set);
   __isl_give isl_union_set *isl_union_set_intersect(
     __isl_take isl_union_set *uset1,
     __isl_take isl_union_set *uset2);
 
   #include <isl/union_map.h>
   __isl_give isl_union_map *isl_union_map_intersect_params(
     __isl_take isl_union_map *umap,
     __isl_take isl_set *set);
   __isl_give isl_union_map *isl_union_map_intersect_domain(
     __isl_take isl_union_map *umap,
     __isl_take isl_union_set *uset);
   __isl_give isl_union_map *isl_union_map_intersect_range(
     __isl_take isl_union_map *umap,
     __isl_take isl_union_set *uset);
   __isl_give isl_union_map *isl_union_map_intersect(
     __isl_take isl_union_map *umap1,
     __isl_take isl_union_map *umap2);
+  __isl_give isl_union_map *
+  isl_union_map_intersect_range_factor_range(
+    __isl_take isl_union_map *umap,
+    __isl_take isl_union_map *factor);
 
   #include <isl/aff.h>
   __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
     __isl_take isl_pw_aff *pa,
     __isl_take isl_set *set);
   __isl_give isl_multi_pw_aff *
   isl_multi_pw_aff_intersect_domain(
     __isl_take isl_multi_pw_aff *mpa,
A representation of the schedule node can be printed using
   __isl_give char *isl_schedule_node_to_str(
     __isl_keep isl_schedule_node *node);
 
 C<isl_schedule_node_to_str> prints the schedule node in block format.
 
 =head2 Dependence Analysis
 
 C<isl> contains specialized functionality for performing
-array dataflow analysis.  That is, given a I<sink> access relation
-and a collection of possible I<source> access relations,
+array dataflow analysis.  That is, given a I<sink> access relation,
+a collection of possible I<source> accesses and
+a collection of I<kill> accesses,
 C<isl> can compute relations that describe
-for each iteration of the sink access, which iteration
-of which of the source access relations was the last
-to access the same data element before the given iteration
-of the sink access.
+for each iteration of the sink access, which iterations
+of which of the source access relations may have
+accessed the same data element before the given iteration
+of the sink access without any intermediate kill of that data element.
 The resulting dependence relations map source iterations
 to either the corresponding sink iterations or
 pairs of corresponding sink iterations and accessed data elements.
 To compute standard flow dependences, the sink should be
 a read, while the sources should be writes.
-If any of the source accesses are marked as being I<may>
-accesses, then there will be a (may) dependence from the last
-I<must> access B<and> from any I<may> access that follows
-this last I<must> access, but still precedes the sink access.
-Only dependences originating in a must access and without
-any may accesses between the must access and the sink access
-are considered to be must dependences.
-In particular, if I<all> sources are I<may> accesses,
+If no kills are specified,
 then memory based dependence analysis is performed.
-If, on the other hand, all sources are I<must> accesses,
+If, on the other hand, all sources are also kills,
 then value based dependence analysis is performed.
+If any of the source accesses are marked as being I<must>
+accesses, then they are also treated as kills.
+Furthermore, the specification of must-sources results
+in the computation of must-dependences.
+Only dependences originating in a must access not coscheduled
+with any other access to the same element and without
+any may accesses between the must access and the sink access
+are considered to be must dependences.
 
 =head3 High-level Interface
 
 A high-level interface to dependence analysis is provided
 by the following function.
 
   #include <isl/flow.h>
   __isl_give isl_union_flow *

 An C<isl_union_access_info> is created, modified, copied and freed using
 the following functions.
 
   #include <isl/flow.h>
   __isl_give isl_union_access_info *
   isl_union_access_info_from_sink(
     __isl_take isl_union_map *sink);
   __isl_give isl_union_access_info *
-  isl_union_access_info_set_must_source(
+  isl_union_access_info_set_kill(
     __isl_take isl_union_access_info *access,
-    __isl_take isl_union_map *must_source);
+    __isl_take isl_union_map *kill);
   __isl_give isl_union_access_info *
   isl_union_access_info_set_may_source(
     __isl_take isl_union_access_info *access,
     __isl_take isl_union_map *may_source);
   __isl_give isl_union_access_info *
+  isl_union_access_info_set_must_source(
+    __isl_take isl_union_access_info *access,
+    __isl_take isl_union_map *must_source);
+  __isl_give isl_union_access_info *
   isl_union_access_info_set_schedule(
     __isl_take isl_union_access_info *access,
     __isl_take isl_schedule *schedule);
   __isl_give isl_union_access_info *
   isl_union_access_info_set_schedule_map(
     __isl_take isl_union_access_info *access,
     __isl_take isl_union_map *schedule_map);
   __isl_give isl_union_access_info *
   isl_union_access_info_copy(
     __isl_keep isl_union_access_info *access);
   __isl_null isl_union_access_info *
   isl_union_access_info_free(
     __isl_take isl_union_access_info *access);
 
 The may sources set by C<isl_union_access_info_set_may_source>
 do not need to include the must sources set by
 C<isl_union_access_info_set_must_source> as a subset.
-The user is free not to call one (or both) of these functions,
+The kills set by C<isl_union_access_info_set_kill> may overlap
+with the may-sources and/or must-sources.
+The user is free not to call one (or more) of these functions,
 in which case the corresponding set is kept to its empty default.
 Similarly, the default schedule initialized by
 C<isl_union_access_info_from_sink> is empty.
 The current schedule is determined by the last call to either
 C<isl_union_access_info_set_schedule> or
 C<isl_union_access_info_set_schedule_map>.
 The domain of the schedule corresponds to the domains of
 the access relations.  In particular, the domains of the access
 relations are effectively intersected with the domain of the schedule
 and only the resulting accesses are considered by the dependence analysis.
 
+An C<isl_union_access_info> object can be read from input
+using the following function.
+
+  #include <isl/flow.h>
+  __isl_give isl_union_access_info *
+  isl_union_access_info_read_from_file(isl_ctx *ctx,
+    FILE *input);
+
 A representation of the information contained in an object
 of type C<isl_union_access_info> can be obtained using
 
   #include <isl/flow.h>
   __isl_give isl_printer *
   isl_printer_print_union_access_info(
     __isl_take isl_printer *p,
     __isl_keep isl_union_access_info *access);

 
 The input is collected in an C<isl_access_info>, which can
 be created through a call to C<isl_access_info_alloc>.
 The arguments to this functions are the sink access relation
 C<sink>, a token C<sink_user> used to identify the sink
 access to the user, a callback function for specifying the
 relative order of source and sink accesses, and the number
 of source access relations that will be added.
+
 The callback function has type C<int (*)(void *first, void *second)>.
 The function is called with two user supplied tokens identifying
 either a source or the sink and it should return the shared nesting
 level and the relative order of the two accesses.
 In particular, let I<n> be the number of loops shared by
 the two accesses.  If C<first> precedes C<second> textually,
 then the function should return I<2 * n + 1>; otherwise,
 it should return I<2 * n>.
-The sources can be added to the C<isl_access_info> by performing
+The low-level interface assumes that no sources are coscheduled.
+If the information returned by the callback does not allow
+the relative order to be determined, then one of the sources
+is arbitrarily taken to be executed after the other(s).
+
+The sources can be added to the C<isl_access_info> object by performing
 (at most) C<max_source> calls to C<isl_access_info_add_source>.
 C<must> indicates whether the source is a I<must> access
 or a I<may> access.  Note that a multi-valued access relation
 should only be marked I<must> if every iteration in the domain
 of the relation accesses I<all> elements in its image.
 The C<source_user> token is again used to identify
 the source access.  The range of the source access relation
 C<source> should have the same dimension as the range
 of the sink access relation.
 The C<isl_access_info_free> function should usually not be
-called explicitly, because it is called implicitly by
+called explicitly, because it is already called implicitly by
 C<isl_access_info_compute_flow>.
 
 The result of the dependence analysis is collected in an
 C<isl_flow>.  There may be elements of
 the sink access for which no preceding source access could be
 found or for which all preceding sources are I<may> accesses.
 The relations containing these elements can be obtained through
 calls to C<isl_flow_get_no_source>, the first with C<must> set
=head3 Options
   isl_stat isl_options_set_schedule_treat_coalescing(
     isl_ctx *ctx, int val);
   int isl_options_get_schedule_treat_coalescing(
     isl_ctx *ctx);
   isl_stat isl_options_set_schedule_algorithm(
     isl_ctx *ctx, int val);
   int isl_options_get_schedule_algorithm(
     isl_ctx *ctx);
+  isl_stat isl_options_set_schedule_carry_self_first(
+    isl_ctx *ctx, int val);
+  int isl_options_get_schedule_carry_self_first(
+    isl_ctx *ctx);
   isl_stat isl_options_set_schedule_separate_components(
     isl_ctx *ctx, int val);
   int isl_options_get_schedule_separate_components(
     isl_ctx *ctx);
 
 =over
 
 =item * schedule_max_coefficient

 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
 
 =item * schedule_split_scaled
 
 If this option is set, then we try to construct schedules in which the
 constant term is split off from the linear part if the linear parts of
 the scheduling rows for all nodes in the graph have a common non-trivial
 divisor.
-The constant term is then placed in a separate band and the linear
+The constant term is then dropped and the linear
 part is reduced.
 This option is only effective when the Feautrier style scheduler is
 being used, either as the main scheduler or as a fallback for the
 Pluto-like scheduler.
 
 =item * schedule_treat_coalescing
 
 If this option is set, then the scheduler will try and avoid
 producing schedules that perform loop coalescing.
 In particular, for the Pluto-like scheduler, this option places
 bounds on the schedule coefficients based on the sizes of the instance sets.
 For the Feautrier style scheduler, this option detects potentially
 coalescing schedules and then tries to adjust the schedule to avoid
 the coalescing.
 
+=item * schedule_carry_self_first
+
+If this option is set, then the Feautrier style scheduler
+(when used as a fallback for the Pluto-like scheduler) will
+first try to only carry self-dependences.
+
 =item * schedule_separate_components
 
 If this option is set then the function C<isl_schedule_get_map>
 will treat set nodes in the same way as sequence nodes.
 
 =back
 
 =head2 AST Generation

 If an affine objective function
 is given, then the constant should appear in the last column.
 
 =head2 C<isl_polytope_scan>
 
 Given a polytope, C<isl_polytope_scan> prints
 all integer points in the polytope.
 
+=head2 C<isl_flow>
+
+Given an C<isl_union_access_info> object as input,
+C<isl_flow> prints out the corresponding dependences,
+as computed by C<isl_union_access_info_compute_flow>.
+
 =head2 C<isl_codegen>
 
 Given either a schedule tree or a sequence consisting of
 a schedule map, a context set and an options relation,
 C<isl_codegen> prints out an AST that scans the domain elements
 of the schedule in the order of their image(s) taking into account
 the constraints in the context set.
 
 =head2 C<isl_schedule>
 
 Given an C<isl_schedule_constraints> object as input,
 C<isl_schedule> prints out a schedule that satisfies the given
 constraints.

polly/trunk/lib/External/isl/extract_key.c

+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <string.h>
+
+/* Extract a mapping key from the token "tok".
+ * Return KEY_ERROR on error, i.e., if "tok" does not
+ * correspond to any known key.
+ */
+static KEY extract_key(__isl_keep isl_stream *s, struct isl_token *tok)
+{
+  int type;
+  char *name;
+  KEY key;
+  isl_ctx *ctx;
+
+  if (!tok)
+    return KEY_ERROR;
+  type = isl_token_get_type(tok);
+  if (type != ISL_TOKEN_IDENT && type != ISL_TOKEN_STRING) {
+    isl_stream_error(s, tok, "expecting key");
+    return KEY_ERROR;
+  }
+
+  ctx = isl_stream_get_ctx(s);
+  name = isl_token_get_str(ctx, tok);
+  if (!name)
+    return KEY_ERROR;
+
+  for (key = 0; key < KEY_END; ++key) {
+    if (!strcmp(name, key_str[key]))
+      break;
+  }
+  free(name);
+
+  if (key >= KEY_END)
+    isl_die(ctx, isl_error_invalid, "unknown key",
+      return KEY_ERROR);
+  return key;
+}
+
+/* Read a key from "s" and return the corresponding enum.
+ * Return KEY_ERROR on error, i.e., if the first token
+ * on the stream does not correspond to any known key.
+ */
+static KEY get_key(__isl_keep isl_stream *s)
+{
+  struct isl_token *tok;
+  KEY key;
+
+  tok = isl_stream_next_token(s);
+  key = extract_key(s, tok);
+  isl_token_free(tok);
+
+  return key;
+}

polly/trunk/lib/External/isl/flow.c

+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* This program takes an isl_union_access_info object as input and
+ * prints the corresponding dependences.
+ */
+
+#include <isl/options.h>
+#include <isl/printer.h>
+#include <isl/union_map.h>
+#include <isl/flow.h>
+#include <isl/schedule.h>
+
+int main(int argc, char **argv)
+{
+  isl_ctx *ctx;
+  isl_printer *p;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+  struct isl_options *options;
+
+  options = isl_options_new_with_defaults();
+  argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
+  ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
+
+  access = isl_union_access_info_read_from_file(ctx, stdin);
+  flow = isl_union_access_info_compute_flow(access);
+
+  p = isl_printer_to_file(ctx, stdout);
+  p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
+  p = isl_printer_print_union_flow(p, flow);
+  isl_printer_free(p);
+
+  isl_union_flow_free(flow);
+
+  isl_ctx_free(ctx);
+
+  return 0;
+}

polly/trunk/lib/External/isl/flow_cmp.c

+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <stdlib.h>
+
+#include <isl/arg.h>
+#include <isl/options.h>
+#include <isl/union_map.h>
+#include <isl/stream.h>
+
+struct options {
+  struct isl_options *isl;
+  char *flow1;
+  char *flow2;
+};
+
+ISL_ARGS_START(struct options, options_args)
+ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
+ISL_ARG_ARG(struct options, flow1, "flow1", NULL)
+ISL_ARG_ARG(struct options, flow2, "flow2", NULL)
+ISL_ARGS_END
+
+ISL_ARG_DEF(options, struct options, options_args)
+
+static void die(const char *msg)
+{
+  fprintf(stderr, "%s\n", msg);
+  exit(EXIT_FAILURE);
+}
+
+static FILE *open_or_die(const char *filename)
+{
+  FILE *file;
+
+  file = fopen(filename, "r");
+  if (!file) {
+    fprintf(stderr, "Unable to open %s\n", filename);
+    exit(EXIT_FAILURE);
+  }
+  return file;
+}
+
+#undef BASE
+#define BASE union_map
+#include "read_in_string_templ.c"
+
+/* Given two YAML descriptions of isl_union_flow objects, check whether
+ * they are equivalent.
+ * Return EXIT_SUCCESS if they are and EXIT_FAILURE if they are not
+ * or if anything else went wrong.
+ *
+ * The descriptions are checked field by field, meaning that the fields
+ * are expected to appear in the same order in both inputs.
+ */
+int main(int argc, char **argv)
+{
+  int more;
+  isl_ctx *ctx;
+  struct options *options;
+  FILE *input1, *input2;
+  isl_stream *s1, *s2;
+
+  options = options_new_with_defaults();
+  if (!options)
+    return EXIT_FAILURE;
+
+  ctx = isl_ctx_alloc_with_options(&options_args, options);
+  argc = options_parse(options, argc, argv, ISL_ARG_ALL);
+
+  input1 = open_or_die(options->flow1);
+  input2 = open_or_die(options->flow2);
+  s1 = isl_stream_new_file(ctx, input1);
+  s2 = isl_stream_new_file(ctx, input2);
+
+  if (isl_stream_yaml_read_start_mapping(s1))
+    isl_die(ctx, isl_error_unknown, "arg1 not a YAML mapping",
+      return EXIT_FAILURE);
+  if (isl_stream_yaml_read_start_mapping(s2))
+    isl_die(ctx, isl_error_unknown, "arg2 not a YAML mapping",
+      return EXIT_FAILURE);
+
+  while ((more = isl_stream_yaml_next(s1)) > 0) {
+    int more2;
+    isl_bool equal;
+    isl_union_map *umap1, *umap2;
+
+    more2 = isl_stream_yaml_next(s2);
+    if (more2 < 0)
+      return EXIT_FAILURE;
+    if (!more2)
+      isl_die(ctx, isl_error_unknown, "arg2 shorter",
+        return EXIT_FAILURE);
+    if (isl_stream_eat(s1, ISL_TOKEN_IDENT) < 0)
+      return EXIT_FAILURE;
+    if (isl_stream_eat(s2, ISL_TOKEN_IDENT) < 0)
+      return EXIT_FAILURE;
+    more = isl_stream_yaml_next(s1);
+    more2 = isl_stream_yaml_next(s2);
+    if (more < 0 || more2 < 0)
+      return EXIT_FAILURE;
+    if (!more || !more2)
+      isl_die(ctx, isl_error_unknown, "missing value",
+        return EXIT_FAILURE);
+
+    umap1 = read_union_map(s1);
+    umap2 = read_union_map(s2);
+    equal = isl_union_map_is_equal(umap1, umap2);
+    isl_union_map_free(umap1);
+    isl_union_map_free(umap2);
+    if (equal < 0)
+      return EXIT_FAILURE;
+    if (!equal)
+      die("field not equal");
+  }
+  if (more < 0)
+    return EXIT_FAILURE;
+
+
+  if (isl_stream_yaml_read_end_mapping(s1) < 0) {
+    isl_stream_error(s1, NULL, "unexpected extra elements");
+    return EXIT_FAILURE;
+  }
+  if (isl_stream_yaml_read_end_mapping(s2) < 0) {
+    isl_stream_error(s2, NULL, "unexpected extra elements");
+    return EXIT_FAILURE;
+  }
+
+  isl_stream_free(s1);
+  isl_stream_free(s2);
+  fclose(input1);
+  fclose(input2);
+  isl_ctx_free(ctx);
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/isl/flow_test.sh.in

+#!/bin/sh
+
+EXEEXT=@EXEEXT@
+srcdir=@srcdir@
+
+failed=0
+
+for i in $srcdir/test_inputs/flow/*.ai; do
+  echo $i;
+  base=`basename $i .ai`
+  test=test-$base.flow
+  dir=`dirname $i`
+  ref=$dir/$base.flow
+  (./isl_flow$EXEEXT < $i > $test &&
+  ./isl_flow_cmp$EXEEXT $ref $test && rm $test) || failed=1
+done
+
+test $failed -eq 0 || exit

polly/trunk/lib/External/isl/imath/imath.c

mp_result mp_int_div_pow2(mp_int a, mp_small p2, mp_int q, mp_int r)
 
   return res;
 }
 
 mp_result mp_int_expt(mp_int a, mp_small b, mp_int c)
 {
   mpz_t t;
   mp_result res;
-  unsigned int v = abs(b);
+  unsigned int v = labs(b);
 
   CHECK(c != NULL);
   if (b < 0)
     return MP_RANGE;
 
   if ((res = mp_int_init_copy(&t, a)) != MP_OK)
     return res;
 
CLEANUP:
   mp_int_clear(&t);
   return res;
 }
 
 mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c)
 {
   mpz_t     t;
   mp_result res;
-  unsigned int v = abs(b);
+  unsigned int v = labs(b);
 
   CHECK(c != NULL);
   if (b < 0)
     return MP_RANGE;
 
   if ((res = mp_int_init_value(&t, a)) != MP_OK)
     return res;
 
mp_result mp_int_to_int(mp_int z, mp_small *out)
 
   while (uz > 0) {
     uv <<= MP_DIGIT_BIT/2;
     uv = (uv << (MP_DIGIT_BIT/2)) | *dz--;
     --uz;
   }
 
   if (out)
-    *out = (sz == MP_NEG) ? -(mp_small)uv : (mp_small)uv;
+    *out = (mp_small)((sz == MP_NEG) ? -uv : uv);
 
   return MP_OK;
 }
 
 mp_result mp_int_to_uint(mp_int z, mp_usmall *out)
 {
   mp_usmall uv = 0;
   mp_size   uz;
STATIC void     s_qdiv(mp_int z, mp_size p2)
   if (MP_USED(z) == 1 && z->digits[0] == 0)
     MP_SIGN(z) = MP_ZPOS;
 }
 
 STATIC void     s_qmod(mp_int z, mp_size p2)
 {
   mp_size start = p2 / MP_DIGIT_BIT + 1, rest = p2 % MP_DIGIT_BIT;
   mp_size uz = MP_USED(z);
-  mp_digit mask = (1 << rest) - 1;
+  mp_digit mask = (1u << rest) - 1;
 
   if (start <= uz) {
     MP_USED(z) = start;
     z->digits[start - 1] &= mask;
     CLAMP(z);
   }
 }
 
STATIC int       s_2expt(mp_int z, mp_small k)
   return 1;
 }
 
 STATIC int      s_norm(mp_int a, mp_int b)
 {
   mp_digit d = b->digits[MP_USED(b) - 1];
   int k = 0;
 
-  while (d < (mp_digit) (1 << (MP_DIGIT_BIT - 1))) { /* d < (MP_RADIX / 2) */
+  while (d < (1u << (mp_digit)(MP_DIGIT_BIT - 1))) { /* d < (MP_RADIX / 2) */
     d <<= 1;
     ++k;
   }
 
   /* These multiplications can't fail */
   if (k != 0) {
     (void) s_qmul(a, (mp_size) k);
     (void) s_qmul(b, (mp_size) k);
res = MP_MEMORY; goto CLEANUP;
     }
     (void) mp_int_copy(TEMP(0), a);
   }
 
   CLEANUP_TEMP();
   return res;
 }
 
-#if 0
-/*
-  The s_udiv function produces incorrect results. For example, with test
-     div:11141460315522012760862883825:48318382095:0,230584300062375935
-   commenting out the function for now and using s_udiv_knuth instead.
-   STATIC mp_result s_udiv(mp_int a, mp_int b);
-*/
-/* Precondition:  a >= b and b > 0
-   Postcondition: a' = a / b, b' = a % b
- */
-STATIC mp_result s_udiv(mp_int a, mp_int b)
-{
-  mpz_t q, r, t;
-  mp_size ua, ub, qpos = 0;
-  mp_digit *da, btop;
-  mp_result res = MP_OK;
-  int k, skip = 0;
-
-  /* Force signs to positive */
-  MP_SIGN(a) = MP_ZPOS;
-  MP_SIGN(b) = MP_ZPOS;
-
-  /* Normalize, per Knuth */
-  k = s_norm(a, b);
-
-  ua = MP_USED(a); ub = MP_USED(b); btop = b->digits[ub - 1];
-  if ((res = mp_int_init_size(&q, ua)) != MP_OK) return res;
-  if ((res = mp_int_init_size(&t, ua + 1)) != MP_OK) goto CLEANUP;
-
-  da = MP_DIGITS(a);
-  r.digits = da + ua - 1;  /* The contents of r are shared with a */
-  r.used   = 1;
-  r.sign   = MP_ZPOS;
-  r.alloc  = MP_ALLOC(a);
-  ZERO(t.digits, t.alloc);
-
-  /* Solve for quotient digits, store in q.digits in reverse order */
-  while (r.digits >= da) {
-    assert(qpos <= q.alloc);
-
-    if (s_ucmp(b, &r) > 0) {
-      r.digits -= 1;
-      r.used += 1;
-
-      if (++skip > 1 && qpos > 0)
-  q.digits[qpos++] = 0;
-
-      CLAMP(&r);
-    }
-    else {
-      mp_word  pfx = r.digits[r.used - 1];
-      mp_word  qdigit;
-
-      if (r.used > 1 && pfx < btop) {
-  pfx <<= MP_DIGIT_BIT / 2;
-  pfx <<= MP_DIGIT_BIT / 2;
-  pfx |= r.digits[r.used - 2];
-      }
-
-      qdigit = pfx / btop;
-      if (qdigit > MP_DIGIT_MAX) {
-  qdigit = MP_DIGIT_MAX;
-      }
-
-      s_dbmul(MP_DIGITS(b), (mp_digit) qdigit, t.digits, ub);
-      t.used = ub + 1; CLAMP(&t);
-      while (s_ucmp(&t, &r) > 0) {
-  --qdigit;
-  (void) mp_int_sub(&t, b, &t); /* cannot fail */
-      }
-
-      s_usub(r.digits, t.digits, r.digits, r.used, t.used);
-      CLAMP(&r);
-
-      q.digits[qpos++] = (mp_digit) qdigit;
-      ZERO(t.digits, t.used);
-      skip = 0;
-    }
-  }
-
-  /* Put quotient digits in the correct order, and discard extra zeroes */
-  q.used = qpos;
-  REV(mp_digit, q.digits, qpos);
-  CLAMP(&q);
-
-  /* Denormalize the remainder */
-  CLAMP(a);
-  if (k != 0)
-    s_qdiv(a, k);
-
-  mp_int_copy(a, b);  /* ok:  0 <= r < b */
-  mp_int_copy(&q, a); /* ok:  q <= a     */
-
-  mp_int_clear(&t);
- CLEANUP:
-  mp_int_clear(&q);
-  return res;
-}
-#endif
-
 /* Division of nonnegative integers
 
    This function implements division algorithm for unsigned multi-precision
    integers. The algorithm is based on Algorithm D from Knuth's "The Art of
    Computer Programming", 3rd ed. 1998, pg 272-273.
 
    We diverge from Knuth's algorithm in that we do not perform the subtraction
    from the remainder until we have determined that we have the correct
STATIC mp_result s_udiv_knuth(mp_int u, mp_int v) {
   if (MP_USED(v) == 1) {
     mp_digit d, rem;
     d   = v->digits[0];
     rem = s_ddiv(u, d);
     mp_int_set_value(v, rem);
     return MP_OK;
   }
 
-  /************************************************************/
-  /* Algorithm D */
-  /************************************************************/
-  /* The n and m variables are defined as used by Knuth.
+  /* Algorithm D
+
+     The n and m variables are defined as used by Knuth.
      u is an n digit number with digits u_{n-1}..u_0.
      v is an n+m digit number with digits from v_{m+n-1}..v_0.
-     We require that n > 1 and m >= 0 */
+     We require that n > 1 and m >= 0
+   */
   n = MP_USED(v);
   m = MP_USED(u) - n;
-  assert(n >  1);
+  assert(n > 1);
   assert(m >= 0);
 
-  /************************************************************/
   /* D1: Normalize.
      The normalization step provides the necessary condition for Theorem B,
      which states that the quotient estimate for q_j, call it qhat
 
        qhat = u_{j+n}u_{j+n-1} / v_{n-1}
 
      is bounded by
 
       qhat - 2 <= q_j <= qhat.
 
      That is, qhat is always greater than the actual quotient digit q,
-     and it is never more than two larger than the actual quotient digit.  */
+     and it is never more than two larger than the actual quotient digit.
+   */
   k = s_norm(u, v);
 
   /* Extend size of u by one if needed.
 
      The algorithm begins with a value of u that has one more digit of input.
      The normalization step sets u_{m+n}..u_0 = 2^k * u_{m+n-1}..u_0. If the
      multiplication did not increase the number of digits of u, we need to add
      a leading zero here.
    */
   if (k == 0 || MP_USED(u) != m + n + 1) {
     if (!s_pad(u, m+n+1))
       return MP_MEMORY;
     u->digits[m+n] = 0;
     u->used = m+n+1;
   }
 
   /* Add a leading 0 to v.
 
      The multiplication in step D4 multiplies qhat * 0v_{n-1}..v_0.  We need to
      add the leading zero to v here to ensure that the multiplication will
-     produce the full n+1 digit result.  */
+     produce the full n+1 digit result.
+   */
   if (!s_pad(v, n+1)) return MP_MEMORY; v->digits[n] = 0;
 
   /* Initialize temporary variables q and t.
      q allocates space for m+1 digits to store the quotient digits
-     t allocates space for n+1 digits to hold the result of q_j*v */
+     t allocates space for n+1 digits to hold the result of q_j*v
+   */
   if ((res = mp_int_init_size(&q, m + 1)) != MP_OK) return res;
   if ((res = mp_int_init_size(&t, n + 1)) != MP_OK) goto CLEANUP;
 
-  /************************************************************/
   /* D2: Initialize j */
   j = m;
   r.digits = MP_DIGITS(u) + j;  /* The contents of r are shared with u */
   r.used   = n + 1;
   r.sign   = MP_ZPOS;
   r.alloc  = MP_ALLOC(u);
   ZERO(t.digits, t.alloc);
 
   /* Calculate the m+1 digits of the quotient result */
   for (; j >= 0; j--) {
-    /************************************************************/
     /* D3: Calculate q' */
     /* r->digits is aligned to position j of the number u */
     mp_word pfx, qhat;
     pfx   = r.digits[n];
     pfx <<= MP_DIGIT_BIT / 2;
     pfx <<= MP_DIGIT_BIT / 2;
     pfx |= r.digits[n-1]; /* pfx = u_{j+n}{j+n-1} */
 
     qhat = pfx / v->digits[n-1];
     /* Check to see if qhat > b, and decrease qhat if so.
        Theorem B guarantess that qhat is at most 2 larger than the
        actual value, so it is possible that qhat is greater than
        the maximum value that will fit in a digit */
     if (qhat > MP_DIGIT_MAX)
       qhat = MP_DIGIT_MAX;
 
-    /************************************************************/
     /* D4,D5,D6: Multiply qhat * v and test for a correct value of q
 
        We proceed a bit different than the way described by Knuth. This way is
        simpler but less efficent. Instead of doing the multiply and subtract
        then checking for underflow, we first do the multiply of qhat * v and
        see if it is larger than the current remainder r. If it is larger, we
        decrease qhat by one and try again. We may need to decrease qhat one
        more time before we get a value that is smaller than r.
 
        This way is less efficent than Knuth becuase we do more multiplies, but
-       we do not need to worry about underflow this way.  */
+       we do not need to worry about underflow this way.
+     */
     /* t = qhat * v */
     s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1); t.used = n + 1;
     CLAMP(&t);
 
     /* Clamp r for the comparison. Comparisons do not like leading zeros. */
     CLAMP(&r);
     if (s_ucmp(&t, &r) > 0) {   /* would the remainder be negative? */
       qhat -= 1;   /* try a smaller q */
       s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1);
       t.used = n + 1; CLAMP(&t);
       if (s_ucmp(&t, &r) > 0) { /* would the remainder be negative? */
         assert(qhat > 0);
         qhat -= 1; /* try a smaller q */
         s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1);
         t.used = n + 1; CLAMP(&t);
       }
       assert(s_ucmp(&t, &r) <=  0 && "The mathematics failed us.");
     }
     /* Unclamp r. The D algorithm expects r = u_{j+n}..u_j to always be n+1
        digits long. */
     r.used = n + 1;
 
-    /************************************************************/
-    /* D4: Multiply and subtract */
-    /* note: The multiply was completed above so we only need to subtract here.
-     **/
+    /* D4: Multiply and subtract
+
+       Note: The multiply was completed above so we only need to subtract here.
+     */
     s_usub(r.digits, t.digits, r.digits, r.used, t.used);
 
-    /************************************************************/
-    /* D5: Test remainder */
-    /* note: Not needed because we always check that qhat is the correct value
-     *       before performing the subtract.
-     *       Value cast to mp_digit to prevent warning, qhat has been clamped to MP_DIGIT_MAX */
+    /* D5: Test remainder
+
+       Note: Not needed because we always check that qhat is the correct value
+             before performing the subtract.  Value cast to mp_digit to prevent
+             warning, qhat has been clamped to MP_DIGIT_MAX
+     */
     q.digits[j] = (mp_digit)qhat;
 
-    /************************************************************/
-    /* D6: Add back */
-    /* note: Not needed because we always check that qhat is the correct value
-     *       before performing the subtract. */
+    /* D6: Add back
+       Note: Not needed because we always check that qhat is the correct value
+             before performing the subtract.
+     */
 
-    /************************************************************/
     /* D7: Loop on j */
     r.digits--;
     ZERO(t.digits, t.alloc);
   }
 
   /* Get rid of leading zeros in q */
   q.used = m + 1;
   CLAMP(&q);

polly/trunk/lib/External/isl/imath_wrap/wrap.h

 #define impz_cmp  isl_impz_cmp
 #define impz_cmpabs isl_impz_cmpabs
 #define impz_cmp_si isl_impz_cmp_si
 #define impz_divexact isl_impz_divexact
 #define impz_divexact_ui  isl_impz_divexact_ui
 #define impz_divisible_p  isl_impz_divisible_p
 #define impz_export isl_impz_export
 #define impz_fdiv_q isl_impz_fdiv_q
-#define impz_fdiv_q_ui  isl_impz_fdiv_q_ui
 #define impz_fdiv_r isl_impz_fdiv_r
 #define impz_gcd  isl_impz_gcd
 #define impz_get_si isl_impz_get_si
 #define impz_get_str  isl_impz_get_str
 #define impz_get_ui isl_impz_get_ui
 #define impz_import isl_impz_import
 #define impz_init isl_impz_init
 #define impz_lcm  isl_impz_lcm

polly/trunk/lib/External/isl/include/isl/aff.h

__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_gist(
   __isl_take isl_union_set *context);
 __isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_gist_params(
   __isl_take isl_multi_union_pw_aff *aff, __isl_take isl_set *context);
 
 __isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_aff(
   __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff);
 __isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_multi_aff(
   __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma);
-__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_multi_aff(
-  __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma);
+__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff(
+  __isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa);
 __isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_pw_multi_aff(
   __isl_take isl_multi_union_pw_aff *mupa,
   __isl_take isl_pw_multi_aff *pma);
 
 __isl_overload
 __isl_give isl_multi_union_pw_aff *
 isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
   __isl_take isl_multi_union_pw_aff *mupa,

polly/trunk/lib/External/isl/include/isl/flow.h

 #ifndef ISL_FLOW_H
 #define ISL_FLOW_H
 
+#include <stdio.h>
+
 #include <isl/set_type.h>
 #include <isl/map_type.h>
 #include <isl/union_set_type.h>
 #include <isl/union_map_type.h>
 #include <isl/schedule.h>
 #include <isl/printer.h>
 
 #if defined(__cplusplus)

 __isl_give isl_union_access_info *isl_union_access_info_set_must_source(
   __isl_take isl_union_access_info *access,
   __isl_take isl_union_map *must_source);
 __isl_export
 __isl_give isl_union_access_info *isl_union_access_info_set_may_source(
   __isl_take isl_union_access_info *access,
   __isl_take isl_union_map *may_source);
 __isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_kill(
+  __isl_take isl_union_access_info *access,
+  __isl_take isl_union_map *kill);
+__isl_export
 __isl_give isl_union_access_info *isl_union_access_info_set_schedule(
   __isl_take isl_union_access_info *access,
   __isl_take isl_schedule *schedule);
 __isl_export
 __isl_give isl_union_access_info *isl_union_access_info_set_schedule_map(
   __isl_take isl_union_access_info *access,
   __isl_take isl_union_map *schedule_map);
 __isl_give isl_union_access_info *isl_union_access_info_copy(
   __isl_keep isl_union_access_info *access);
 __isl_null isl_union_access_info *isl_union_access_info_free(
   __isl_take isl_union_access_info *access);
 
 isl_ctx *isl_union_access_info_get_ctx(
   __isl_keep isl_union_access_info *access);
 
+__isl_give isl_union_access_info *isl_union_access_info_read_from_file(
+  isl_ctx *ctx, FILE *input);
 __isl_give isl_printer *isl_printer_print_union_access_info(
   __isl_take isl_printer *p, __isl_keep isl_union_access_info *access);
 __isl_give char *isl_union_access_info_to_str(
   __isl_keep isl_union_access_info *access);
 
 __isl_export
 __isl_give isl_union_flow *isl_union_access_info_compute_flow(
   __isl_take isl_union_access_info *access);

polly/trunk/lib/External/isl/include/isl/map.h

 __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
 __isl_export
 __isl_give isl_map *isl_map_reverse(__isl_take isl_map *map);
 __isl_export
 __isl_give isl_map *isl_map_union(
     __isl_take isl_map *map1,
     __isl_take isl_map *map2);
-struct isl_map *isl_map_union_disjoint(
-      struct isl_map *map1, struct isl_map *map2);
+__isl_give isl_map *isl_map_union_disjoint(
+    __isl_take isl_map *map1, __isl_take isl_map *map2);
 __isl_export
 __isl_give isl_map *isl_map_intersect_domain(
     __isl_take isl_map *map,
     __isl_take isl_set *set);
 __isl_export
 __isl_give isl_map *isl_map_intersect_range(
     __isl_take isl_map *map,
     __isl_take isl_set *set);
+__isl_give isl_map *isl_map_intersect_domain_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor);
+__isl_give isl_map *isl_map_intersect_range_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor);
 __isl_export
 __isl_give isl_map *isl_map_apply_domain(
     __isl_take isl_map *map1,
     __isl_take isl_map *map2);
 __isl_export
 __isl_give isl_map *isl_map_apply_range(
     __isl_take isl_map *map1,
     __isl_take isl_map *map2);

polly/trunk/lib/External/isl/include/isl/schedule.h

 int isl_options_get_schedule_separate_components(isl_ctx *ctx);
 
 isl_stat isl_options_set_schedule_serialize_sccs(isl_ctx *ctx, int val);
 int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
 
 isl_stat isl_options_set_schedule_whole_component(isl_ctx *ctx, int val);
 int isl_options_get_schedule_whole_component(isl_ctx *ctx);
 
+isl_stat isl_options_set_schedule_carry_self_first(isl_ctx *ctx, int val);
+int isl_options_get_schedule_carry_self_first(isl_ctx *ctx);
+
 __isl_give isl_schedule_constraints *isl_schedule_constraints_copy(
   __isl_keep isl_schedule_constraints *sc);
 __isl_give isl_schedule_constraints *isl_schedule_constraints_on_domain(
   __isl_take isl_union_set *domain);
 __isl_give isl_schedule_constraints *isl_schedule_constraints_set_context(
   __isl_take isl_schedule_constraints *sc, __isl_take isl_set *context);
 __isl_give isl_schedule_constraints *isl_schedule_constraints_set_validity(
   __isl_take isl_schedule_constraints *sc,

polly/trunk/lib/External/isl/include/isl/set.h

 __isl_give isl_basic_set *isl_basic_set_fix_si(__isl_take isl_basic_set *bset,
     enum isl_dim_type type, unsigned pos, int value);
 __isl_give isl_basic_set *isl_basic_set_fix_val(__isl_take isl_basic_set *bset,
   enum isl_dim_type type, unsigned pos, __isl_take isl_val *v);
 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos, int value);
 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
     enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_basic_set *isl_basic_set_lower_bound_val(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  __isl_take isl_val *value);
 __isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
   enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
 __isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
   enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_basic_set *isl_basic_set_upper_bound_val(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  __isl_take isl_val *value);
 __isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
   enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
 
 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
   enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2);
 
 __isl_export
 isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_set *bset1,

polly/trunk/lib/External/isl/include/isl/union_map.h

__isl_give isl_union_map *isl_union_map_gist_range(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
 
 __isl_export
 __isl_give isl_union_map *isl_union_map_intersect_domain(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
 __isl_export
 __isl_give isl_union_map *isl_union_map_intersect_range(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_range(
+  __isl_take isl_union_map *umap, __isl_take isl_union_map *factor);
 
 __isl_export
 __isl_give isl_union_map *isl_union_map_subtract_domain(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *dom);
 __isl_export
 __isl_give isl_union_map *isl_union_map_subtract_range(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *dom);
 

polly/trunk/lib/External/isl/include/isl/val.h

 __isl_export
 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2);
 __isl_export
 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2);
 __isl_export
 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2);
+__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2);
 __isl_export
 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_export
 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
   __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y);
 
 __isl_export

polly/trunk/lib/External/isl/isl_aff.c

 #include <isl_multi_templ.c>
 #include <isl_multi_apply_set.c>
 #include <isl_multi_cmp.c>
 #include <isl_multi_floor.c>
 #include <isl_multi_gist.c>
 
 #undef NO_DOMAIN
 
+/* Construct an isl_multi_aff living in "space" that corresponds
+ * to the affine transformation matrix "mat".
+ */
+__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
+  __isl_take isl_space *space, __isl_take isl_mat *mat)
+{
+  isl_ctx *ctx;
+  isl_local_space *ls = NULL;
+  isl_multi_aff *ma = NULL;
+  int n_row, n_col, n_out, total;
+  int i;
+
+  if (!space || !mat)
+    goto error;
+
+  ctx = isl_mat_get_ctx(mat);
+
+  n_row = isl_mat_rows(mat);
+  n_col = isl_mat_cols(mat);
+  if (n_row < 1)
+    isl_die(ctx, isl_error_invalid,
+      "insufficient number of rows", goto error);
+  if (n_col < 1)
+    isl_die(ctx, isl_error_invalid,
+      "insufficient number of columns", goto error);
+  n_out = isl_space_dim(space, isl_dim_out);
+  total = isl_space_dim(space, isl_dim_all);
+  if (1 + n_out != n_row || 2 + total != n_row + n_col)
+    isl_die(ctx, isl_error_invalid,
+      "dimension mismatch", goto error);
+
+  ma = isl_multi_aff_zero(isl_space_copy(space));
+  ls = isl_local_space_from_space(isl_space_domain(space));
+
+  for (i = 0; i < n_row - 1; ++i) {
+    isl_vec *v;
+    isl_aff *aff;
+
+    v = isl_vec_alloc(ctx, 1 + n_col);
+    if (!v)
+      goto error;
+    isl_int_set(v->el[0], mat->row[0][0]);
+    isl_seq_cpy(v->el + 1, mat->row[1 + i], n_col);
+    v = isl_vec_normalize(v);
+    aff = isl_aff_alloc_vec(isl_local_space_copy(ls), v);
+    ma = isl_multi_aff_set_aff(ma, i, aff);
+  }
+
+  isl_local_space_free(ls);
+  isl_mat_free(mat);
+  return ma;
+error:
+  isl_local_space_free(ls);
+  isl_mat_free(mat);
+  isl_multi_aff_free(ma);
+  return NULL;
+}
+
 /* Remove any internal structure of the domain of "ma".
  * If there is any such internal structure in the input,
  * then the name of the corresponding space is also removed.
  */
 __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
   __isl_take isl_multi_aff *ma)
 {
   isl_space *space;

polly/trunk/lib/External/isl/isl_aff_private.h

 __isl_give isl_multi_aff *isl_multi_aff_dup(__isl_keep isl_multi_aff *multi);
 
 __isl_give isl_multi_aff *isl_multi_aff_align_divs(
   __isl_take isl_multi_aff *maff);
 
 __isl_give isl_multi_aff *isl_multi_aff_from_basic_set_equalities(
   __isl_take isl_basic_set *bset);
 
+__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
+  __isl_take isl_space *space, __isl_take isl_mat *mat);
+
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_domain_space(
   __isl_take isl_pw_multi_aff *pwmaff, __isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_space(
   __isl_take isl_pw_multi_aff *pwmaff, __isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add_disjoint(
   __isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
 
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_project_out(

polly/trunk/lib/External/isl/isl_config.h.in

 #undef HAVE___ATTRIBUTE__
 
 /* Return type of HandleTopLevelDeclReturn */
 #undef HandleTopLevelDeclContinue
 
 /* Return type of HandleTopLevelDeclReturn */
 #undef HandleTopLevelDeclReturn
 
+/* Define to InputKind::C for newer versions of clang */
+#undef IK_C
+
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #undef LT_OBJDIR
 
 /* Name of package */
 #undef PACKAGE
 
 /* Define to the address where bug reports for this package should be sent. */
 #undef PACKAGE_BUGREPORT

polly/trunk/lib/External/isl/isl_convex_hull.c

static __isl_give isl_basic_set *convex_hull_pair(
   return convex_hull_pair_pointed(bset1, bset2);
 error:
   isl_basic_set_free(bset1);
   isl_basic_set_free(bset2);
   return NULL;
 }
 
 /* Compute the lineality space of a basic set.
- * We currently do not allow the basic set to have any divs.
  * We basically just drop the constants and turn every inequality
  * into an equality.
+ * Any explicit representations of local variables are removed
+ * because they may no longer be valid representations
+ * in the lineality space.
  */
 __isl_give isl_basic_set *isl_basic_set_lineality_space(
   __isl_take isl_basic_set *bset)
 {
   int i, k;
   struct isl_basic_set *lin = NULL;
-  unsigned dim;
+  unsigned n_div, dim;
 
   if (!bset)
     goto error;
-  isl_assert(bset->ctx, bset->n_div == 0, goto error);
+  n_div = isl_basic_set_dim(bset, isl_dim_div);
   dim = isl_basic_set_total_dim(bset);
 
-  lin = isl_basic_set_alloc_space(isl_basic_set_get_space(bset), 0, dim, 0);
+  lin = isl_basic_set_alloc_space(isl_basic_set_get_space(bset),
+          n_div, dim, 0);
+  for (i = 0; i < n_div; ++i)
+    if (isl_basic_set_alloc_div(lin) < 0)
+      goto error;
   if (!lin)
     goto error;
   for (i = 0; i < bset->n_eq; ++i) {
     k = isl_basic_set_alloc_equality(lin);
     if (k < 0)
       goto error;
     isl_int_set_si(lin->eq[k][0], 0);
     isl_seq_cpy(lin->eq[k] + 1, bset->eq[i] + 1, dim);
__isl_give isl_basic_set *isl_basic_set_lineality_space(
   return lin;
 error:
   isl_basic_set_free(lin);
   isl_basic_set_free(bset);
   return NULL;
 }
 
 /* Compute the (linear) hull of the lineality spaces of the basic sets in the
- * "underlying" set "set".
+ * set "set".
  */
-static __isl_give isl_basic_set *uset_combined_lineality_space(
+__isl_give isl_basic_set *isl_set_combined_lineality_space(
   __isl_take isl_set *set)
 {
   int i;
   struct isl_set *lin = NULL;
 
   if (!set)
     return NULL;
   if (set->n == 0) {
if (isl_set_n_dim(set) == 1)
     return convex_hull_1d(set);
 
   bounded = isl_set_is_bounded(set);
   if (bounded < 0)
     goto error;
   if (bounded && set->ctx->opt->convex == ISL_CONVEX_HULL_WRAP)
     return uset_convex_hull_wrap(set);
 
-  lin = uset_combined_lineality_space(isl_set_copy(set));
+  lin = isl_set_combined_lineality_space(isl_set_copy(set));
   if (!lin)
     goto error;
   if (isl_basic_set_plain_is_universe(lin)) {
     isl_set_free(set);
     return lin;
   }
   if (lin->n_eq < isl_basic_set_total_dim(lin))
     return modulo_lineality(set, lin);
if (!dummy)
     goto error;
   isl_basic_set_free(dummy);
   set = isl_set_preimage(set, T);
   convex_hull = uset_convex_hull(set);
   convex_hull = isl_basic_set_preimage(convex_hull, T2);
   convex_hull = isl_basic_set_intersect(convex_hull, affine_hull);
   return convex_hull;
 error:
+  isl_mat_free(T);
+  isl_mat_free(T2);
   isl_basic_set_free(affine_hull);
   isl_set_free(set);
   return NULL;
 }
 
 /* Return an empty basic map living in the same space as "map".
  */
 static __isl_give isl_basic_map *replace_map_by_empty_basic_map(

polly/trunk/lib/External/isl/isl_dim_map.h

 #ifndef ISL_DIM_MAP_H
 #define ISL_DIM_MAP_H
 
 #include <isl/ctx.h>
 #include <isl/space.h>
 #include <isl/map.h>
 #include <isl_reordering.h>
 
 struct isl_dim_map;
 typedef struct isl_dim_map isl_dim_map;
 
 __isl_give isl_dim_map *isl_dim_map_alloc(isl_ctx *ctx, unsigned len);
 void isl_dim_map_range(__isl_keep isl_dim_map *dim_map,
-  unsigned dst_pos, unsigned dst_stride,
-  unsigned src_pos, unsigned src_stride,
+  unsigned dst_pos, int dst_stride, unsigned src_pos, int src_stride,
   unsigned n, int sign);
 void isl_dim_map_dim_range(__isl_keep isl_dim_map *dim_map,
   isl_space *dim, enum isl_dim_type type,
   unsigned first, unsigned n, unsigned dst_pos);
 void isl_dim_map_dim(__isl_keep isl_dim_map *dim_map, __isl_keep isl_space *dim,
   enum isl_dim_type type, unsigned dst_pos);
 void isl_dim_map_div(__isl_keep isl_dim_map *dim_map,
   __isl_keep isl_basic_map *bmap, unsigned dst_pos);

polly/trunk/lib/External/isl/isl_dim_map.c

__isl_give isl_dim_map *isl_dim_map_alloc(isl_ctx *ctx, unsigned len)
   dim_map->m[0].pos = 0;
   dim_map->m[0].sgn = 1;
   for (i = 0; i < len; ++i)
     dim_map->m[1 + i].sgn = 0;
   return dim_map;
 }
 
 void isl_dim_map_range(__isl_keep isl_dim_map *dim_map,
-  unsigned dst_pos, unsigned dst_stride,
-  unsigned src_pos, unsigned src_stride,
+  unsigned dst_pos, int dst_stride, unsigned src_pos, int src_stride,
   unsigned n, int sign)
 {
   int i;
 
   if (!dim_map)
     return;
 
   for (i = 0; i < n; ++i) {

polly/trunk/lib/External/isl/isl_flow.c

 
 #include <isl/set.h>
 #include <isl/map.h>
 #include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl/flow.h>
 #include <isl/schedule_node.h>
 #include <isl_sort.h>
+#include <isl/stream.h>
 
 enum isl_restriction_type {
   isl_restriction_type_empty,
   isl_restriction_type_none,
   isl_restriction_type_input,
   isl_restriction_type_output
 };
 

  * the map represents a must or may access/dependence.
  */
 struct isl_labeled_map {
   struct isl_map  *map;
   void    *data;
   int   must;
 };
 
+typedef int (*isl_access_coscheduled)(void *first, void *second);
+
 /* A structure containing the input for dependence analysis:
  * - a sink
  * - n_must + n_may (<= max_source) sources
  * - a function for determining the relative order of sources and sink
+ * - an optional function "coscheduled" for determining whether sources
+ *   may be coscheduled.  If "coscheduled" is NULL, then the sources
+ *   are assumed not to be coscheduled.
  * The must sources are placed before the may sources.
  *
  * domain_map is an auxiliary map that maps the sink access relation
  * to the domain of this access relation.
  * This field is only needed when restrict_fn is set and
  * the field itself is set by isl_access_info_compute_flow.
  *
  * restrict_fn is a callback that (if not NULL) will be called
  * right before any lexicographical maximization.
  */
 struct isl_access_info {
   isl_map       *domain_map;
   struct isl_labeled_map    sink;
   isl_access_level_before   level_before;
+  isl_access_coscheduled    coscheduled;
 
   isl_access_restrict   restrict_fn;
   void        *restrict_user;
 
   int           max_source;
   int           n_must;
   int           n_may;
   struct isl_labeled_map    source[1];
for (level = sink_level; level <= depth; ++level) {
           ran);
       must_rel[k] = isl_map_subtract(must_rel[k], T);
     }
   }
 
   return map;
 }
 
+/* Given a dependence relation "old_map" between a must-source and the sink,
+ * return a subset of the dependences, augmented with instances
+ * of the source at position "pos" in "acc" that are coscheduled
+ * with the must-source and that access the same element.
+ * That is, if the input lives in a space T -> K, then the output
+ * lives in the space [T -> S] -> K, with S the space of source "pos", and
+ * the domain factor of the domain product is a subset of the input.
+ * The sources are considered to be coscheduled if they have the same values
+ * for the initial "depth" coordinates.
+ *
+ * First construct a dependence relation S -> K and a mapping
+ * between coscheduled sources T -> S.
+ * The second is combined with the original dependence relation T -> K
+ * to form a relation in T -> [S -> K], which is subsequently
+ * uncurried to [T -> S] -> K.
+ * This result is then intersected with the dependence relation S -> K
+ * to form the output.
+ */
+static __isl_give isl_map *coscheduled_source(__isl_keep isl_access_info *acc,
+  __isl_keep isl_map *old_map, int pos, int depth)
+{
+  isl_space *space;
+  isl_set *set_C;
+  isl_map *read_map;
+  isl_map *write_map;
+  isl_map *dep_map;
+  isl_map *equal;
+  isl_map *map;
+
+  set_C = isl_map_range(isl_map_copy(old_map));
+  read_map = isl_map_copy(acc->sink.map);
+  read_map = isl_map_intersect_domain(read_map, set_C);
+  write_map = isl_map_copy(acc->source[pos].map);
+  dep_map = isl_map_domain_product(write_map, read_map);
+  dep_map = isl_set_unwrap(isl_map_domain(dep_map));
+  space = isl_space_join(isl_map_get_space(old_map),
+        isl_space_reverse(isl_map_get_space(dep_map)));
+  equal = isl_map_from_basic_map(isl_basic_map_equal(space, depth));
+  map = isl_map_range_product(equal, isl_map_copy(old_map));
+  map = isl_map_uncurry(map);
+  map = isl_map_intersect_domain_factor_range(map, dep_map);
+
+  return map;
+}
+
+/* After the dependences derived from a must-source have been computed
+ * at a certain level, check if any of the sources of the must-dependences
+ * may be coscheduled with other sources.
+ * If they are any such sources, then there is no way of determining
+ * which of the sources actually comes last and the must-dependences
+ * need to be turned into may-dependences, while dependences from
+ * the other sources need to be added to the may-dependences as well.
+ * "acc" describes the sources and a callback for checking whether
+ * two sources may be coscheduled.  If acc->coscheduled is NULL then
+ * the sources are assumed not to be coscheduled.
+ * "must_rel" and "may_rel" describe the must and may-dependence relations
+ * computed at the current level for the must-sources.  Some of the dependences
+ * may be moved from "must_rel" to "may_rel".
+ * "flow" contains all dependences computed so far (apart from those
+ * in "must_rel" and "may_rel") and may be updated with additional
+ * dependences derived from may-sources.
+ *
+ * In particular, consider all the must-sources with a non-empty
+ * dependence relation in "must_rel".  They are considered in reverse
+ * order because that is the order in which they are considered in the caller.
+ * If any of the must-sources are coscheduled, then the last one
+ * is the one that will have a corresponding dependence relation.
+ * For each must-source i, consider both all the previous must-sources
+ * and all the may-sources.  If any of those may be coscheduled with
+ * must-source i, then compute the coscheduled instances that access
+ * the same memory elements.  The result is a relation [T -> S] -> K.
+ * The projection onto T -> K is a subset of the must-dependence relation
+ * that needs to be turned into may-dependences.
+ * The projection onto S -> K needs to be added to the may-dependences
+ * of source S.
+ * Since a given must-source instance may be coscheduled with several
+ * other source instances, the dependences that need to be turned
+ * into may-dependences are first collected and only actually removed
+ * from the must-dependences after all other sources have been considered.
+ */
+static __isl_give isl_flow *handle_coscheduled(__isl_keep isl_access_info *acc,
+  __isl_keep isl_map **must_rel, __isl_keep isl_map **may_rel,
+  __isl_take isl_flow *flow)
+{
+  int i, j;
+
+  if (!acc->coscheduled)
+    return flow;
+  for (i = acc->n_must - 1; i >= 0; --i) {
+    isl_map *move;
+
+    if (isl_map_plain_is_empty(must_rel[i]))
+      continue;
+    move = isl_map_empty(isl_map_get_space(must_rel[i]));
+    for (j = i - 1; j >= 0; --j) {
+      int depth;
+      isl_map *map, *factor;
+
+      if (!acc->coscheduled(acc->source[i].data,
+            acc->source[j].data))
+        continue;
+      depth = acc->level_before(acc->source[i].data,
+            acc->source[j].data) / 2;
+      map = coscheduled_source(acc, must_rel[i], j, depth);
+      factor = isl_map_domain_factor_range(isl_map_copy(map));
+      may_rel[j] = isl_map_union(may_rel[j], factor);
+      map = isl_map_domain_factor_domain(map);
+      move = isl_map_union(move, map);
+    }
+    for (j = 0; j < acc->n_may; ++j) {
+      int depth, pos;
+      isl_map *map, *factor;
+
+      pos = acc->n_must + j;
+      if (!acc->coscheduled(acc->source[i].data,
+            acc->source[pos].data))
+        continue;
+      depth = acc->level_before(acc->source[i].data,
+            acc->source[pos].data) / 2;
+      map = coscheduled_source(acc, must_rel[i], pos, depth);
+      factor = isl_map_domain_factor_range(isl_map_copy(map));
+      pos = 2 * acc->n_must + j;
+      flow->dep[pos].map = isl_map_union(flow->dep[pos].map,
+                  factor);
+      map = isl_map_domain_factor_domain(map);
+      move = isl_map_union(move, map);
+    }
+    must_rel[i] = isl_map_subtract(must_rel[i], isl_map_copy(move));
+    may_rel[i] = isl_map_union(may_rel[i], move);
+  }
+
+  return flow;
+}
+
 /* Compute dependences for the case where all accesses are "may"
  * accesses, which boils down to computing memory based dependences.
  * The generic algorithm would also work in this case, but it would
  * be overkill to use it.
  */
 static __isl_give isl_flow *compute_mem_based_dependences(
   __isl_keep isl_access_info *acc)
 {

  *      and replace possible last accesses dep by the remainder
  *
  *
  * The above algorithm is applied to the must access.  During the course
  * of the algorithm, we keep track of sink iterations that still
  * need to be considered.  These iterations are split into those that
  * haven't been matched to any source access (mustdo) and those that have only
  * been matched to may accesses (maydo).
- * At the end of each level, we also consider the may accesses.
+ * At the end of each level, must-sources and may-sources that are coscheduled
+ * with the sources of the must-dependences at that level are considered.
+ * If any coscheduled instances are found, then corresponding may-dependences
+ * are added and the original must-dependences are turned into may-dependences.
+ * Afterwards, the may accesses that occur after must-dependence sources
+ * are considered.
  * In particular, we consider may accesses that precede the remaining
  * sink iterations, moving elements from mustdo to maydo when appropriate,
  * and may accesses that occur between a must source and a sink of any 
  * dependences found at the current level, turning must dependences into
  * may dependences when appropriate.
  * 
  */
 static __isl_give isl_flow *compute_val_based_dependences(
for (j = j - 1; j >= 0; --j) {
                  acc->sink.data);
       if (!can_precede_at_level(plevel, level))
         continue;
 
       intermediate_sources(acc, must_rel, j, level);
       intermediate_sources(acc, may_rel, j, level);
     }
 
+    handle_coscheduled(acc, must_rel, may_rel, res);
+
     for (j = 0; j < acc->n_may; ++j) {
       int plevel;
       isl_map *T;
       isl_set *ran;
 
       plevel = acc->level_before(acc->source[acc->n_must + j].data,
                  acc->sink.data);
       if (!can_precede_at_level(plevel, level))
static __isl_give struct isl_sched_info *sched_info_alloc(
   }
 
   return info;
 error:
   sched_info_free(info);
   return NULL;
 }
 
+/* The different types of access relations that isl_union_access_info
+ * keeps track of.
+
+ * "isl_access_sink" represents the sink accesses.
+ * "isl_access_must_source" represents the definite source accesses.
+ * "isl_access_may_source" represents the possible source accesses.
+ * "isl_access_kill" represents the kills.
+ *
+ * isl_access_sink is sometimes treated differently and
+ * should therefore appear first.
+ */
+enum isl_access_type {
+  isl_access_sink,
+  isl_access_must_source,
+  isl_access_may_source,
+  isl_access_kill,
+  isl_access_end
+};
+
 /* This structure represents the input for a dependence analysis computation.
  *
- * "sink" represents the sink accesses.
- * "must_source" represents the definite source accesses.
- * "may_source" represents the possible source accesses.
+ * "access" contains the access relations.
  *
  * "schedule" or "schedule_map" represents the execution order.
  * Exactly one of these fields should be NULL.  The other field
  * determines the execution order.
  *
  * The domains of these four maps refer to the same iteration spaces(s).
  * The ranges of the first three maps also refer to the same data space(s).
  *
  * After a call to isl_union_access_info_introduce_schedule,
  * the "schedule_map" field no longer contains useful information.
  */
 struct isl_union_access_info {
-  isl_union_map *sink;
-  isl_union_map *must_source;
-  isl_union_map *may_source;
+  isl_union_map *access[isl_access_end];
 
   isl_schedule *schedule;
   isl_union_map *schedule_map;
 };
 
 /* Free "access" and return NULL.
  */
 __isl_null isl_union_access_info *isl_union_access_info_free(
   __isl_take isl_union_access_info *access)
 {
+  enum isl_access_type i;
+
   if (!access)
     return NULL;
 
-  isl_union_map_free(access->sink);
-  isl_union_map_free(access->must_source);
-  isl_union_map_free(access->may_source);
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    isl_union_map_free(access->access[i]);
   isl_schedule_free(access->schedule);
   isl_union_map_free(access->schedule_map);
   free(access);
 
   return NULL;
 }
 
 /* Return the isl_ctx to which "access" belongs.
  */
 isl_ctx *isl_union_access_info_get_ctx(__isl_keep isl_union_access_info *access)
 {
-  return access ? isl_union_map_get_ctx(access->sink) : NULL;
+  if (!access)
+    return NULL;
+  return isl_union_map_get_ctx(access->access[isl_access_sink]);
+}
+
+/* Construct an empty (invalid) isl_union_access_info object.
+ * The caller is responsible for setting the sink access relation and
+ * initializing all the other fields, e.g., by calling
+ * isl_union_access_info_init.
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_alloc(
+  isl_ctx *ctx)
+{
+  return isl_calloc_type(ctx, isl_union_access_info);
 }
 
-/* Create a new isl_union_access_info with the given sink accesses and
- * and no source accesses or schedule information.
+/* Initialize all the fields of "info", except the sink access relation,
+ * which is assumed to have been set by the caller.
  *
  * By default, we use the schedule field of the isl_union_access_info,
  * but this may be overridden by a call
  * to isl_union_access_info_set_schedule_map.
  */
+static __isl_give isl_union_access_info *isl_union_access_info_init(
+  __isl_take isl_union_access_info *info)
+{
+  isl_space *space;
+  isl_union_map *empty;
+  enum isl_access_type i;
+
+  if (!info)
+    return NULL;
+  if (!info->access[isl_access_sink])
+    return isl_union_access_info_free(info);
+
+  space = isl_union_map_get_space(info->access[isl_access_sink]);
+  empty = isl_union_map_empty(isl_space_copy(space));
+  for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+    if (!info->access[i])
+      info->access[i] = isl_union_map_copy(empty);
+  isl_union_map_free(empty);
+  if (!info->schedule && !info->schedule_map)
+    info->schedule = isl_schedule_empty(isl_space_copy(space));
+  isl_space_free(space);
+
+  for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+    if (!info->access[i])
+      return isl_union_access_info_free(info);
+  if (!info->schedule && !info->schedule_map)
+    return isl_union_access_info_free(info);
+
+  return info;
+}
+
+/* Create a new isl_union_access_info with the given sink accesses and
+ * and no other accesses or schedule information.
+ */
 __isl_give isl_union_access_info *isl_union_access_info_from_sink(
   __isl_take isl_union_map *sink)
 {
   isl_ctx *ctx;
-  isl_space *space;
-  isl_union_map *empty;
   isl_union_access_info *access;
 
   if (!sink)
     return NULL;
   ctx = isl_union_map_get_ctx(sink);
-  access = isl_alloc_type(ctx, isl_union_access_info);
+  access = isl_union_access_info_alloc(ctx);
   if (!access)
     goto error;
+  access->access[isl_access_sink] = sink;
+  return isl_union_access_info_init(access);
+error:
+  isl_union_map_free(sink);
+  return NULL;
+}
 
-  space = isl_union_map_get_space(sink);
-  empty = isl_union_map_empty(isl_space_copy(space));
-  access->sink = sink;
-  access->must_source = isl_union_map_copy(empty);
-  access->may_source = empty;
-  access->schedule = isl_schedule_empty(space);
-  access->schedule_map = NULL;
+/* Replace the access relation of type "type" of "info" by "access".
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_set(
+  __isl_take isl_union_access_info *info,
+  enum isl_access_type type, __isl_take isl_union_map *access)
+{
+  if (!info || !access)
+    goto error;
 
-  if (!access->sink || !access->must_source ||
-      !access->may_source || !access->schedule)
-    return isl_union_access_info_free(access);
+  isl_union_map_free(info->access[type]);
+  info->access[type] = access;
 
-  return access;
+  return info;
 error:
-  isl_union_map_free(sink);
+  isl_union_access_info_free(info);
+  isl_union_map_free(access);
   return NULL;
 }
 
 /* Replace the definite source accesses of "access" by "must_source".
  */
 __isl_give isl_union_access_info *isl_union_access_info_set_must_source(
   __isl_take isl_union_access_info *access,
   __isl_take isl_union_map *must_source)
 {
-  if (!access || !must_source)
-    goto error;
-
-  isl_union_map_free(access->must_source);
-  access->must_source = must_source;
-
-  return access;
-error:
-  isl_union_access_info_free(access);
-  isl_union_map_free(must_source);
-  return NULL;
+  return isl_union_access_info_set(access, isl_access_must_source,
+          must_source);
 }
 
 /* Replace the possible source accesses of "access" by "may_source".
  */
 __isl_give isl_union_access_info *isl_union_access_info_set_may_source(
   __isl_take isl_union_access_info *access,
   __isl_take isl_union_map *may_source)
 {
-  if (!access || !may_source)
-    goto error;
+  return isl_union_access_info_set(access, isl_access_may_source,
+          may_source);
+}
 
-  isl_union_map_free(access->may_source);
-  access->may_source = may_source;
+/* Replace the kills of "info" by "kill".
+ */
+__isl_give isl_union_access_info *isl_union_access_info_set_kill(
+  __isl_take isl_union_access_info *info, __isl_take isl_union_map *kill)
+{
+  return isl_union_access_info_set(info, isl_access_kill, kill);
+}
 
-  return access;
-error:
-  isl_union_access_info_free(access);
-  isl_union_map_free(may_source);
+/* Return the access relation of type "type" of "info".
+ */
+static __isl_give isl_union_map *isl_union_access_info_get(
+  __isl_keep isl_union_access_info *info, enum isl_access_type type)
+{
+  if (!info)
     return NULL;
+  return isl_union_map_copy(info->access[type]);
+}
+
+/* Return the definite source accesses of "info".
+ */
+__isl_give isl_union_map *isl_union_access_info_get_must_source(
+  __isl_keep isl_union_access_info *info)
+{
+  return isl_union_access_info_get(info, isl_access_must_source);
+}
+
+/* Return the possible source accesses of "info".
+ */
+__isl_give isl_union_map *isl_union_access_info_get_may_source(
+  __isl_keep isl_union_access_info *info)
+{
+  return isl_union_access_info_get(info, isl_access_may_source);
+}
+
+/* Return the kills of "info".
+ */
+__isl_give isl_union_map *isl_union_access_info_get_kill(
+  __isl_keep isl_union_access_info *info)
+{
+  return isl_union_access_info_get(info, isl_access_kill);
+}
+
+/* Does "info" specify any kills?
+ */
+static isl_bool isl_union_access_has_kill(
+  __isl_keep isl_union_access_info *info)
+{
+  isl_bool empty;
+
+  if (!info)
+    return isl_bool_error;
+  empty = isl_union_map_is_empty(info->access[isl_access_kill]);
+  return isl_bool_not(empty);
 }
 
 /* Replace the schedule of "access" by "schedule".
  * Also free the schedule_map in case it was set last.
  */
 __isl_give isl_union_access_info *isl_union_access_info_set_schedule(
   __isl_take isl_union_access_info *access,
   __isl_take isl_schedule *schedule)
error:
   isl_union_map_free(schedule_map);
   return NULL;
 }
 
 __isl_give isl_union_access_info *isl_union_access_info_copy(
   __isl_keep isl_union_access_info *access)
 {
   isl_union_access_info *copy;
+  enum isl_access_type i;
 
   if (!access)
     return NULL;
   copy = isl_union_access_info_from_sink(
-        isl_union_map_copy(access->sink));
-  copy = isl_union_access_info_set_must_source(copy,
-        isl_union_map_copy(access->must_source));
-  copy = isl_union_access_info_set_may_source(copy,
-        isl_union_map_copy(access->may_source));
+        isl_union_map_copy(access->access[isl_access_sink]));
+  for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+    copy = isl_union_access_info_set(copy, i,
+          isl_union_map_copy(access->access[i]));
   if (access->schedule)
     copy = isl_union_access_info_set_schedule(copy,
         isl_schedule_copy(access->schedule));
   else
     copy = isl_union_access_info_set_schedule_map(copy,
         isl_union_map_copy(access->schedule_map));
 
   return copy;
static __isl_give isl_printer *print_union_map_field(__isl_take isl_printer *p,
   p = isl_printer_print_str(p, "\"");
   p = isl_printer_print_union_map(p, umap);
   p = isl_printer_print_str(p, "\"");
   p = isl_printer_yaml_next(p);
 
   return p;
 }
 
+/* An enumeration of the various keys that may appear in a YAML mapping
+ * of an isl_union_access_info object.
+ * The keys for the access relation types are assumed to have the same values
+ * as the access relation types in isl_access_type.
+ */
+enum isl_ai_key {
+  isl_ai_key_error = -1,
+  isl_ai_key_sink = isl_access_sink,
+  isl_ai_key_must_source = isl_access_must_source,
+  isl_ai_key_may_source = isl_access_may_source,
+  isl_ai_key_kill = isl_access_kill,
+  isl_ai_key_schedule_map,
+  isl_ai_key_schedule,
+  isl_ai_key_end
+};
+
+/* Textual representations of the YAML keys for an isl_union_access_info
+ * object.
+ */
+static char *key_str[] = {
+  [isl_ai_key_sink] = "sink",
+  [isl_ai_key_must_source] = "must_source",
+  [isl_ai_key_may_source] = "may_source",
+  [isl_ai_key_kill] = "kill",
+  [isl_ai_key_schedule_map] = "schedule_map",
+  [isl_ai_key_schedule] = "schedule",
+};
+
+/* Print a key-value pair corresponding to the access relation of type "type"
+ * of a YAML mapping of "info" to "p".
+ *
+ * The sink access relation is always printed, but any other access relation
+ * is only printed if it is non-empty.
+ */
+static __isl_give isl_printer *print_access_field(__isl_take isl_printer *p,
+  __isl_keep isl_union_access_info *info, enum isl_access_type type)
+{
+  if (type != isl_access_sink) {
+    isl_bool empty;
+
+    empty = isl_union_map_is_empty(info->access[type]);
+    if (empty < 0)
+      return isl_printer_free(p);
+    if (empty)
+      return p;
+  }
+  return print_union_map_field(p, key_str[type], info->access[type]);
+}
+
 /* Print the information contained in "access" to "p".
  * The information is printed as a YAML document.
  */
 __isl_give isl_printer *isl_printer_print_union_access_info(
   __isl_take isl_printer *p, __isl_keep isl_union_access_info *access)
 {
+  enum isl_access_type i;
+
   if (!access)
     return isl_printer_free(p);
 
   p = isl_printer_yaml_start_mapping(p);
-  p = print_union_map_field(p, "sink", access->sink);
-  p = print_union_map_field(p, "must_source", access->must_source);
-  p = print_union_map_field(p, "may_source", access->may_source);
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    p = print_access_field(p, access, i);
   if (access->schedule) {
-    p = isl_printer_print_str(p, "schedule");
+    p = isl_printer_print_str(p, key_str[isl_ai_key_schedule]);
     p = isl_printer_yaml_next(p);
     p = isl_printer_print_schedule(p, access->schedule);
     p = isl_printer_yaml_next(p);
   } else {
-    p = print_union_map_field(p, "schedule_map",
+    p = print_union_map_field(p, key_str[isl_ai_key_schedule_map],
             access->schedule_map);
   }
   p = isl_printer_yaml_end_mapping(p);
 
   return p;
 }
 
 /* Return a string representation of the information in "access".
__isl_give char *isl_union_access_info_to_str(
   p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_FLOW);
   p = isl_printer_print_union_access_info(p, access);
   s = isl_printer_get_str(p);
   isl_printer_free(p);
 
   return s;
 }
 
+#undef KEY
+#define KEY enum isl_ai_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_ai_key_error
+#undef KEY_END
+#define KEY_END isl_ai_key_end
+#include "extract_key.c"
+
+#undef BASE
+#define BASE union_map
+#include "read_in_string_templ.c"
+
+/* Read an isl_union_access_info object from "s".
+ *
+ * Start off with an empty (invalid) isl_union_access_info object and
+ * then fill up the fields based on the input.
+ * The input needs to contain at least a description of the sink
+ * access relation as well as some form of schedule.
+ * The other access relations are set to empty relations
+ * by isl_union_access_info_init if they are not specified in the input.
+ */
+__isl_give isl_union_access_info *isl_stream_read_union_access_info(
+  isl_stream *s)
+{
+  isl_ctx *ctx;
+  isl_union_access_info *info;
+  int more;
+  int sink_set = 0;
+  int schedule_set = 0;
+
+  if (isl_stream_yaml_read_start_mapping(s))
+    return NULL;
+
+  ctx = isl_stream_get_ctx(s);
+  info = isl_union_access_info_alloc(ctx);
+  while ((more = isl_stream_yaml_next(s)) > 0) {
+    enum isl_ai_key key;
+    isl_union_map *access, *schedule_map;
+    isl_schedule *schedule;
+
+    key = get_key(s);
+    if (isl_stream_yaml_next(s) < 0)
+      return isl_union_access_info_free(info);
+    switch (key) {
+    case isl_ai_key_end:
+    case isl_ai_key_error:
+      return isl_union_access_info_free(info);
+    case isl_ai_key_sink:
+      sink_set = 1;
+    case isl_ai_key_must_source:
+    case isl_ai_key_may_source:
+    case isl_ai_key_kill:
+      access = read_union_map(s);
+      info = isl_union_access_info_set(info, key, access);
+      if (!info)
+        return NULL;
+      break;
+    case isl_ai_key_schedule_map:
+      schedule_set = 1;
+      schedule_map = read_union_map(s);
+      info = isl_union_access_info_set_schedule_map(info,
+                schedule_map);
+      if (!info)
+        return NULL;
+      break;
+    case isl_ai_key_schedule:
+      schedule_set = 1;
+      schedule = isl_stream_read_schedule(s);
+      info = isl_union_access_info_set_schedule(info,
+                schedule);
+      if (!info)
+        return NULL;
+      break;
+    }
+  }
+  if (more < 0)
+    return isl_union_access_info_free(info);
+
+  if (isl_stream_yaml_read_end_mapping(s) < 0) {
+    isl_stream_error(s, NULL, "unexpected extra elements");
+    return isl_union_access_info_free(info);
+  }
+
+  if (!sink_set) {
+    isl_stream_error(s, NULL, "no sink specified");
+    return isl_union_access_info_free(info);
+  }
+
+  if (!schedule_set) {
+    isl_stream_error(s, NULL, "no schedule specified");
+    return isl_union_access_info_free(info);
+  }
+
+  return isl_union_access_info_init(info);
+}
+
+/* Read an isl_union_access_info object from the file "input".
+ */
+__isl_give isl_union_access_info *isl_union_access_info_read_from_file(
+  isl_ctx *ctx, FILE *input)
+{
+  isl_stream *s;
+  isl_union_access_info *access;
+
+  s = isl_stream_new_file(ctx, input);
+  if (!s)
+    return NULL;
+  access = isl_stream_read_union_access_info(s);
+  isl_stream_free(s);
+
+  return access;
+}
+
 /* Update the fields of "access" such that they all have the same parameters,
  * keeping in mind that the schedule_map field may be NULL and ignoring
  * the schedule field.
  */
 static __isl_give isl_union_access_info *isl_union_access_info_align_params(
   __isl_take isl_union_access_info *access)
 {
   isl_space *space;
+  enum isl_access_type i;
 
   if (!access)
     return NULL;
 
-  space = isl_union_map_get_space(access->sink);
-  space = isl_space_align_params(space,
-        isl_union_map_get_space(access->must_source));
+  space = isl_union_map_get_space(access->access[isl_access_sink]);
+  for (i = isl_access_sink + 1; i < isl_access_end; ++i)
     space = isl_space_align_params(space,
-        isl_union_map_get_space(access->may_source));
+        isl_union_map_get_space(access->access[i]));
   if (access->schedule_map)
     space = isl_space_align_params(space,
         isl_union_map_get_space(access->schedule_map));
-  access->sink = isl_union_map_align_params(access->sink,
-              isl_space_copy(space));
-  access->must_source = isl_union_map_align_params(access->must_source,
-              isl_space_copy(space));
-  access->may_source = isl_union_map_align_params(access->may_source,
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    access->access[i] =
+      isl_union_map_align_params(access->access[i],
               isl_space_copy(space));
   if (!access->schedule_map) {
     isl_space_free(space);
   } else {
     access->schedule_map =
         isl_union_map_align_params(access->schedule_map, space);
     if (!access->schedule_map)
       return isl_union_access_info_free(access);
   }
 
-  if (!access->sink || !access->must_source || !access->may_source)
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    if (!access->access[i])
       return isl_union_access_info_free(access);
 
   return access;
 }
 
 /* Prepend the schedule dimensions to the iteration domains.
  *
  * That is, if the schedule is of the form
  *

  * Neither the original schedule map nor this updated schedule map
  * are used after the call to this function.
  */
 static __isl_give isl_union_access_info *
 isl_union_access_info_introduce_schedule(
   __isl_take isl_union_access_info *access)
 {
   isl_union_map *sm;
+  enum isl_access_type i;
 
   if (!access)
     return NULL;
 
   sm = isl_union_map_reverse(access->schedule_map);
   sm = isl_union_map_range_map(sm);
-  access->sink = isl_union_map_apply_range(isl_union_map_copy(sm),
-            access->sink);
-  access->may_source = isl_union_map_apply_range(isl_union_map_copy(sm),
-            access->may_source);
-  access->must_source = isl_union_map_apply_range(isl_union_map_copy(sm),
-            access->must_source);
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    access->access[i] =
+      isl_union_map_apply_range(isl_union_map_copy(sm),
+            access->access[i]);
   access->schedule_map = sm;
 
-  if (!access->sink || !access->must_source ||
-      !access->may_source || !access->schedule_map)
+  for (i = isl_access_sink; i < isl_access_end; ++i)
+    if (!access->access[i])
+      return isl_union_access_info_free(access);
+  if (!access->schedule_map)
     return isl_union_access_info_free(access);
 
   return access;
 }
 
 /* This structure represents the result of a dependence analysis computation.
  *
  * "must_dep" represents the full definite dependences
for (i = 0; i < n1; ++i) {
     r = 2 * i + (cmp < 0);
 
     return r;
   }
 
   return 2 * n1;
 }
 
+/* Check if the given two accesses may be coscheduled.
+ * If so, return 1.  Otherwise return 0.
+ *
+ * Two accesses may only be coscheduled if the fixed schedule
+ * coordinates have the same values.
+ */
+static int coscheduled(void *first, void *second)
+{
+  struct isl_sched_info *info1 = first;
+  struct isl_sched_info *info2 = second;
+  int n1, n2;
+  int i;
+
+  n1 = isl_vec_size(info1->cst);
+  n2 = isl_vec_size(info2->cst);
+
+  if (n2 < n1)
+    n1 = n2;
+
+  for (i = 0; i < n1; ++i) {
+    int cmp;
+
+    if (!info1->is_cst[i])
+      continue;
+    if (!info2->is_cst[i])
+      continue;
+    cmp = isl_vec_cmp_element(info1->cst, info2->cst, i);
+    if (cmp != 0)
+      return 0;
+  }
+
+  return 1;
+}
+
 /* Given a sink access, look for all the source accesses that access
  * the same array and perform dataflow analysis on them using
  * isl_access_info_compute_flow_core.
  */
 static isl_stat compute_flow(__isl_take isl_map *map, void *user)
 {
   int i;
   isl_ctx *ctx;
static isl_stat compute_flow(__isl_take isl_map *map, void *user)
   data->source_info = isl_calloc_array(ctx, struct isl_sched_info *,
                data->count);
 
   data->accesses = isl_access_info_alloc(isl_map_copy(map),
         data->sink_info, &before, data->count);
   if (!data->sink_info || (data->count && !data->source_info) ||
       !data->accesses)
     goto error;
+  data->accesses->coscheduled = &coscheduled;
   data->count = 0;
   data->must = 1;
   if (isl_union_map_foreach_map(data->must_source,
           &collect_matching_array, data) < 0)
     goto error;
   data->must = 0;
   if (isl_union_map_foreach_map(data->may_source,
           &collect_matching_array, data) < 0)
if (data->source_info) {
     free(data->source_info);
   }
   isl_space_free(data->dim);
   isl_map_free(map);
 
   return isl_stat_error;
 }
 
+/* Add the kills of "info" to the must-sources.
+ */
+static __isl_give isl_union_access_info *
+isl_union_access_info_add_kill_to_must_source(
+  __isl_take isl_union_access_info *info)
+{
+  isl_union_map *must, *kill;
+
+  must = isl_union_access_info_get_must_source(info);
+  kill = isl_union_access_info_get_kill(info);
+  must = isl_union_map_union(must, kill);
+  return isl_union_access_info_set_must_source(info, must);
+}
+
+/* Drop dependences from "flow" that purely originate from kills.
+ * That is, only keep those dependences that originate from
+ * the original must-sources "must" and/or the original may-sources "may".
+ * In particular, "must" contains the must-sources from before
+ * the kills were added and "may" contains the may-source from before
+ * the kills were removed.
+ *
+ * The dependences are of the form
+ *
+ *  Source -> [Sink -> Data]
+ *
+ * Only those dependences are kept where the Source -> Data part
+ * is a subset of the original may-sources or must-sources.
+ * Of those, only the must-dependences that intersect with the must-sources
+ * remain must-dependences.
+ * If there is some overlap between the may-sources and the must-sources,
+ * then the may-dependences and must-dependences may also overlap.
+ * This should be fine since the may-dependences are only kept
+ * disjoint from the must-dependences for the isl_union_map_compute_flow
+ * interface.  This interface does not support kills, so it will
+ * not end up calling this function.
+ */
+static __isl_give isl_union_flow *isl_union_flow_drop_kill_source(
+  __isl_take isl_union_flow *flow, __isl_take isl_union_map *must,
+  __isl_take isl_union_map *may)
+{
+  isl_union_map *move;
+
+  if (!flow)
+    goto error;
+  move = isl_union_map_copy(flow->must_dep);
+  move = isl_union_map_intersect_range_factor_range(move,
+        isl_union_map_copy(may));
+  may = isl_union_map_union(may, isl_union_map_copy(must));
+  flow->may_dep = isl_union_map_intersect_range_factor_range(
+        flow->may_dep, may);
+  flow->must_dep = isl_union_map_intersect_range_factor_range(
+        flow->must_dep, must);
+  flow->may_dep = isl_union_map_union(flow->may_dep, move);
+  if (!flow->must_dep || !flow->may_dep)
+    return isl_union_flow_free(flow);
+
+  return flow;
+error:
+  isl_union_map_free(must);
+  isl_union_map_free(may);
+  return NULL;
+}
+
 /* Remove the must accesses from the may accesses.
  *
  * A must access always trumps a may access, so there is no need
  * for a must access to also be considered as a may access.  Doing so
  * would only cost extra computations only to find out that
  * the duplicated may access does not make any difference.
  */
 static __isl_give isl_union_access_info *isl_union_access_info_normalize(
   __isl_take isl_union_access_info *access)
 {
   if (!access)
     return NULL;
-  access->may_source = isl_union_map_subtract(access->may_source,
-            isl_union_map_copy(access->must_source));
-  if (!access->may_source)
+  access->access[isl_access_may_source] =
+    isl_union_map_subtract(access->access[isl_access_may_source],
+        isl_union_map_copy(access->access[isl_access_must_source]));
+  if (!access->access[isl_access_may_source])
     return isl_union_access_info_free(access);
 
   return access;
 }
 
 /* Given a description of the "sink" accesses, the "source" accesses and
  * a schedule, compute for each instance of a sink access
  * and for each element accessed by that instance,

  * We first prepend the schedule dimensions to the domain
  * of the accesses so that we can easily compare their relative order.
  * Then we consider each sink access individually in compute_flow.
  */
 static __isl_give isl_union_flow *compute_flow_union_map(
   __isl_take isl_union_access_info *access)
 {
   struct isl_compute_flow_data data;
+  isl_union_map *sink;
 
   access = isl_union_access_info_align_params(access);
   access = isl_union_access_info_introduce_schedule(access);
   if (!access)
     return NULL;
 
-  data.must_source = access->must_source;
-  data.may_source = access->may_source;
+  data.must_source = access->access[isl_access_must_source];
+  data.may_source = access->access[isl_access_may_source];
 
-  data.flow = isl_union_flow_alloc(isl_union_map_get_space(access->sink));
+  sink = access->access[isl_access_sink];
+  data.flow = isl_union_flow_alloc(isl_union_map_get_space(sink));
 
-  if (isl_union_map_foreach_map(access->sink, &compute_flow, &data) < 0)
+  if (isl_union_map_foreach_map(sink, &compute_flow, &data) < 0)
     goto error;
 
   data.flow = isl_union_flow_drop_schedule(data.flow);
 
   isl_union_access_info_free(access);
   return data.flow;
 error:
   isl_union_access_info_free(access);
static isl_bool count_sink_source(__isl_keep isl_schedule_node *node,
   isl_union_map *umap;
   isl_bool r = isl_bool_false;
 
   if (isl_schedule_node_get_type(node) != isl_schedule_node_leaf)
     return isl_bool_true;
 
   domain = isl_schedule_node_get_universe_domain(node);
 
-  umap = isl_union_map_copy(data->access->sink);
+  umap = isl_union_map_copy(data->access->access[isl_access_sink]);
   umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
   data->n_sink += isl_union_map_n_map(umap);
   isl_union_map_free(umap);
   if (!umap)
     r = isl_bool_error;
 
-  umap = isl_union_map_copy(data->access->must_source);
+  umap = isl_union_map_copy(data->access->access[isl_access_must_source]);
   umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
   data->n_source += isl_union_map_n_map(umap);
   isl_union_map_free(umap);
   if (!umap)
     r = isl_bool_error;
 
-  umap = isl_union_map_copy(data->access->may_source);
+  umap = isl_union_map_copy(data->access->access[isl_access_may_source]);
   umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
   data->n_source += isl_union_map_n_map(umap);
   isl_union_map_free(umap);
   if (!umap)
     r = isl_bool_error;
 
   isl_union_set_free(domain);
 
static isl_bool collect_sink_source(__isl_keep isl_schedule_node *node,
 
   data->node = node;
 
   prefix = isl_schedule_node_get_prefix_schedule_relation(node);
   prefix = isl_union_map_reverse(prefix);
   prefix = isl_union_map_range_map(prefix);
 
   data->set_sink = 1;
-  umap = isl_union_map_copy(data->access->sink);
+  umap = isl_union_map_copy(data->access->access[isl_access_sink]);
   umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
   if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
     r = isl_bool_error;
   isl_union_map_free(umap);
 
   data->set_sink = 0;
   data->must = 1;
-  umap = isl_union_map_copy(data->access->must_source);
+  umap = isl_union_map_copy(data->access->access[isl_access_must_source]);
   umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
   if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
     r = isl_bool_error;
   isl_union_map_free(umap);
 
   data->set_sink = 0;
   data->must = 0;
-  umap = isl_union_map_copy(data->access->may_source);
+  umap = isl_union_map_copy(data->access->access[isl_access_may_source]);
   umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
   if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
     r = isl_bool_error;
   isl_union_map_free(umap);
 
   isl_union_map_free(prefix);
 
   return r;
if (isl_schedule_node_get_type(shared) == isl_schedule_node_sequence) {
     before = pos1 < pos2;
   }
 
   isl_schedule_node_free(shared);
 
   return 2 * depth + before;
 }
 
+/* Check if the given two accesses may be coscheduled.
+ * If so, return 1.  Otherwise return 0.
+ *
+ * Two accesses may only be coscheduled if they appear in the same leaf.
+ */
+static int coscheduled_node(void *first, void *second)
+{
+  isl_schedule_node *node1 = first;
+  isl_schedule_node *node2 = second;
+
+  return node1 == node2;
+}
+
 /* Add the scheduled sources from "data" that access
  * the same data space as "sink" to "access".
  */
 static __isl_give isl_access_info *add_matching_sources(
   __isl_take isl_access_info *access, struct isl_scheduled_access *sink,
   struct isl_compute_flow_schedule_data *data)
 {
   int i;
static __isl_give isl_union_flow *compute_single_flow(
   isl_flow *flow;
   isl_map *map;
 
   if (!uf)
     return NULL;
 
   access = isl_access_info_alloc(isl_map_copy(sink->access), sink->node,
           &before_node, data->n_source);
+  if (access)
+    access->coscheduled = &coscheduled_node;
   access = add_matching_sources(access, sink, data);
 
   flow = access_info_compute_flow_core(access);
   if (!flow)
     return isl_union_flow_free(uf);
 
   map = isl_map_domain_factor_range(isl_flow_get_no_source(flow, 1));
   uf->must_no_source = isl_union_map_union(uf->must_no_source,

  * then compute dependences for each scheduled sink individually.
  */
 static __isl_give isl_union_flow *compute_flow_schedule(
   __isl_take isl_union_access_info *access)
 {
   struct isl_compute_flow_schedule_data data = { access };
   int i, n;
   isl_ctx *ctx;
+  isl_space *space;
   isl_union_flow *flow;
 
   ctx = isl_union_access_info_get_ctx(access);
 
   data.n_sink = 0;
   data.n_source = 0;
   if (isl_schedule_foreach_schedule_node_top_down(access->schedule,
             &count_sink_source, &data) < 0)
     goto error;
 
   n = data.n_sink + data.n_source;
   data.sink = isl_calloc_array(ctx, struct isl_scheduled_access, n);
   if (n && !data.sink)
     goto error;
   data.source = data.sink + data.n_sink;
 
   data.n_sink = 0;
   data.n_source = 0;
   if (isl_schedule_foreach_schedule_node_top_down(access->schedule,
               &collect_sink_source, &data) < 0)
     goto error;
 
-  flow = isl_union_flow_alloc(isl_union_map_get_space(access->sink));
+  space = isl_union_map_get_space(access->access[isl_access_sink]);
+  flow = isl_union_flow_alloc(space);
 
   isl_compute_flow_schedule_data_align_params(&data);
 
   for (i = 0; i < data.n_sink; ++i)
     flow = compute_single_flow(flow, &data.sink[i], &data);
 
   isl_compute_flow_schedule_data_clear(&data);
 

  * element accessed by the sink access before this sink access
  * in the sense that there is no intermediate definite source access.
  *
  * The must_no_source and may_no_source elements of the result
  * are subsets of access->sink.  The elements must_dep and may_dep
  * map domain elements of access->{may,must)_source to
  * domain elements of access->sink.
  *
+ * If any kills have been specified, then they are treated as
+ * must-sources internally.  Any dependence that purely derives
+ * from an original kill is removed from the output.
+ *
  * We check whether the schedule is available as a schedule tree
  * or a schedule map and call the corresponding function to perform
  * the analysis.
  */
 __isl_give isl_union_flow *isl_union_access_info_compute_flow(
   __isl_take isl_union_access_info *access)
 {
+  isl_bool has_kill;
+  isl_union_map *must = NULL, *may = NULL;
+  isl_union_flow *flow;
+
+  has_kill = isl_union_access_has_kill(access);
+  if (has_kill < 0)
+    goto error;
+  if (has_kill) {
+    must = isl_union_access_info_get_must_source(access);
+    may = isl_union_access_info_get_may_source(access);
+  }
+  access = isl_union_access_info_add_kill_to_must_source(access);
   access = isl_union_access_info_normalize(access);
   if (!access)
-    return NULL;
+    goto error;
   if (access->schedule)
-    return compute_flow_schedule(access);
+    flow = compute_flow_schedule(access);
   else
-    return compute_flow_union_map(access);
+    flow = compute_flow_union_map(access);
+  if (has_kill)
+    flow = isl_union_flow_drop_kill_source(flow, must, may);
+  return flow;
+error:
+  isl_union_access_info_free(access);
+  isl_union_map_free(must);
+  isl_union_map_free(may);
+  return NULL;
 }
 
 /* Print the information contained in "flow" to "p".
  * The information is printed as a YAML document.
  */
 __isl_give isl_printer *isl_printer_print_union_flow(
   __isl_take isl_printer *p, __isl_keep isl_union_flow *flow)
 {
   isl_union_map *umap;
 
   if (!flow)
     return isl_printer_free(p);
 
   p = isl_printer_yaml_start_mapping(p);
-  p = print_union_map_field(p, "must_dependence", flow->must_dep);
-  umap = isl_union_flow_get_may_dependence(flow);
+  umap = isl_union_flow_get_full_must_dependence(flow);
+  p = print_union_map_field(p, "must_dependence", umap);
+  isl_union_map_free(umap);
+  umap = isl_union_flow_get_full_may_dependence(flow);
   p = print_union_map_field(p, "may_dependence", umap);
   isl_union_map_free(umap);
   p = print_union_map_field(p, "must_no_source", flow->must_no_source);
   umap = isl_union_flow_get_may_no_source(flow);
   p = print_union_map_field(p, "may_no_source", umap);
   isl_union_map_free(umap);
   p = isl_printer_yaml_end_mapping(p);
 

polly/trunk/lib/External/isl/isl_imath.h

 #include <imath.h>
 #include <gmp_compat.h>
 
 uint32_t isl_imath_hash(mp_int v, uint32_t hash);
 int isl_imath_fits_ulong_p(mp_int op);
 int isl_imath_fits_slong_p(mp_int op);
 void isl_imath_addmul_ui(mp_int rop, mp_int op1, unsigned long op2);
 void isl_imath_submul_ui(mp_int rop, mp_int op1, unsigned long op2);
+void isl_imath_cdiv_q_ui(mp_int rop, mp_int op1, unsigned long op2);
+void isl_imath_fdiv_q_ui(mp_int rop, mp_int op1, unsigned long op2);

polly/trunk/lib/External/isl/isl_imath.c

void isl_imath_submul_ui(mp_int rop, mp_int op1, unsigned long op2)
   mp_int_init(&temp);
 
   mp_int_set_uvalue(&temp, op2);
   mp_int_mul(op1, &temp, &temp);
   mp_int_sub(rop, &temp, rop);
 
   mp_int_clear(&temp);
 }
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * positive infinity (Ceil).
+ */
+void isl_imath_cdiv_q_ui(mp_int rop, mp_int lhs, unsigned long rhs)
+{
+  mpz_t temp;
+  mp_int_init(&temp);
+
+  mp_int_set_uvalue(&temp, rhs);
+  impz_cdiv_q(rop, lhs, &temp);
+
+  mp_int_clear(&temp);
+}
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * negative infinity (Floor).
+ */
+void isl_imath_fdiv_q_ui(mp_int rop, mp_int lhs, unsigned long rhs)
+{
+  mpz_t temp;
+  mp_int_init(&temp);
+
+  mp_int_set_uvalue(&temp, rhs);
+  impz_fdiv_q(rop, lhs, &temp);
+
+  mp_int_clear(&temp);
+}

polly/trunk/lib/External/isl/isl_int_gmp.h

 #define isl_int_submul_ui(r,i,j)  mpz_submul_ui(r,i,j)
 
 #define isl_int_gcd(r,i,j)  mpz_gcd(r,i,j)
 #define isl_int_lcm(r,i,j)  mpz_lcm(r,i,j)
 #define isl_int_divexact(r,i,j) mpz_divexact(r,i,j)
 #define isl_int_divexact_ui(r,i,j)  mpz_divexact_ui(r,i,j)
 #define isl_int_tdiv_q(r,i,j) mpz_tdiv_q(r,i,j)
 #define isl_int_cdiv_q(r,i,j) mpz_cdiv_q(r,i,j)
+#define isl_int_cdiv_q_ui(r,i,j)  mpz_cdiv_q_ui(r,i,j)
 #define isl_int_fdiv_q(r,i,j) mpz_fdiv_q(r,i,j)
 #define isl_int_fdiv_r(r,i,j) mpz_fdiv_r(r,i,j)
 #define isl_int_fdiv_q_ui(r,i,j)  mpz_fdiv_q_ui(r,i,j)
 
 #define isl_int_read(r,s) mpz_set_str(r,s,10)
 #define isl_int_sgn(i)    mpz_sgn(i)
 #define isl_int_cmp(i,j)  mpz_cmp(i,j)
 #define isl_int_cmp_si(i,si)  mpz_cmp_si(i,si)

polly/trunk/lib/External/isl/isl_int_imath.h

 #define isl_int_submul_ui(r,i,j)  isl_imath_submul_ui(r,i,j)
 
 #define isl_int_gcd(r,i,j)  impz_gcd(r,i,j)
 #define isl_int_lcm(r,i,j)  impz_lcm(r,i,j)
 #define isl_int_divexact(r,i,j) impz_divexact(r,i,j)
 #define isl_int_divexact_ui(r,i,j)  impz_divexact_ui(r,i,j)
 #define isl_int_tdiv_q(r,i,j) impz_tdiv_q(r,i,j)
 #define isl_int_cdiv_q(r,i,j) impz_cdiv_q(r,i,j)
+#define isl_int_cdiv_q_ui(r,i,j)  isl_imath_cdiv_q_ui(r,i,j)
 #define isl_int_fdiv_q(r,i,j) impz_fdiv_q(r,i,j)
 #define isl_int_fdiv_r(r,i,j) impz_fdiv_r(r,i,j)
-#define isl_int_fdiv_q_ui(r,i,j)  impz_fdiv_q_ui(r,i,j)
+#define isl_int_fdiv_q_ui(r,i,j)  isl_imath_fdiv_q_ui(r,i,j)
 
 #define isl_int_read(r,s) impz_set_str(r,s,10)
 #define isl_int_sgn(i)    impz_sgn(i)
 #define isl_int_cmp(i,j)  impz_cmp(i,j)
 #define isl_int_cmp_si(i,si)  impz_cmp_si(i,si)
 #define isl_int_eq(i,j)   (impz_cmp(i,j) == 0)
 #define isl_int_ne(i,j)   (impz_cmp(i,j) != 0)
 #define isl_int_lt(i,j)   (impz_cmp(i,j) < 0)

polly/trunk/lib/External/isl/isl_int_sioimath.h

inline void isl_sioimath_cdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   }
 
   impz_cdiv_q(isl_sioimath_reinit_big(dst),
       isl_sioimath_bigarg_src(lhs, &lhsscratch),
       isl_sioimath_bigarg_src(rhs, &rhsscratch));
   isl_sioimath_try_demote(dst);
 }
 
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * positive infinity (Ceil).
+ */
+inline void isl_sioimath_cdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+  unsigned long rhs)
+{
+  isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+  int32_t lhssmall, q;
+
+  if (isl_sioimath_decode_small(lhs, &lhssmall) && (rhs <= INT32_MAX)) {
+    if (lhssmall >= 0)
+      q = ((int64_t) lhssmall + ((int64_t) rhs - 1)) /
+          (int64_t) rhs;
+    else
+      q = lhssmall / (int32_t) rhs;
+    isl_sioimath_set_small(dst, q);
+    return;
+  }
+
+  impz_cdiv_q(isl_sioimath_reinit_big(dst),
+      isl_sioimath_bigarg_src(lhs, &lhsscratch),
+      isl_sioimath_uiarg_src(rhs, &rhsscratch));
+  isl_sioimath_try_demote(dst);
+}
+
 /* Divide lhs by rhs, rounding to negative infinity (Floor).
  */
 inline void isl_sioimath_fdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   isl_sioimath_src rhs)
 {
   isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
   int32_t lhssmall, rhssmall;
   int32_t q;

 #define isl_int_submul_ui(r, i, j)  isl_sioimath_submul_ui((r), *(i), j)
 
 #define isl_int_gcd(r, i, j)    isl_sioimath_gcd((r), *(i), *(j))
 #define isl_int_lcm(r, i, j)    isl_sioimath_lcm((r), *(i), *(j))
 #define isl_int_divexact(r, i, j) isl_sioimath_tdiv_q((r), *(i), *(j))
 #define isl_int_divexact_ui(r, i, j)  isl_sioimath_tdiv_q_ui((r), *(i), j)
 #define isl_int_tdiv_q(r, i, j)   isl_sioimath_tdiv_q((r), *(i), *(j))
 #define isl_int_cdiv_q(r, i, j)   isl_sioimath_cdiv_q((r), *(i), *(j))
+#define isl_int_cdiv_q_ui(r, i, j)  isl_sioimath_cdiv_q_ui((r), *(i), j)
 #define isl_int_fdiv_q(r, i, j)   isl_sioimath_fdiv_q((r), *(i), *(j))
 #define isl_int_fdiv_r(r, i, j)   isl_sioimath_fdiv_r((r), *(i), *(j))
 #define isl_int_fdiv_q_ui(r, i, j)  isl_sioimath_fdiv_q_ui((r), *(i), j)
 
 #define isl_int_read(r, s)    isl_sioimath_read((r), s)
 #define isl_int_sgn(i)      isl_sioimath_sgn(*(i))
 #define isl_int_cmp(i, j)   isl_sioimath_cmp(*(i), *(j))
 #define isl_int_cmp_si(i, si)   isl_sioimath_cmp_si(*(i), si)

polly/trunk/lib/External/isl/isl_int_sioimath.c

 }
 
 extern void isl_sioimath_tdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   isl_sioimath_src rhs);
 extern void isl_sioimath_tdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   unsigned long rhs);
 extern void isl_sioimath_cdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   isl_sioimath_src rhs);
+extern void isl_sioimath_cdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+  unsigned long rhs);
 extern void isl_sioimath_fdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   isl_sioimath_src rhs);
 extern void isl_sioimath_fdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   unsigned long rhs);
 extern void isl_sioimath_fdiv_r(isl_sioimath_ptr dst, isl_sioimath_src lhs,
   isl_sioimath_src rhs);
 
 /* Parse a number from a string.

polly/trunk/lib/External/isl/isl_map.c

__isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
   isl_val_free(value);
   return set;
 error:
   isl_val_free(value);
   isl_set_free(set);
   return NULL;
 }
 
+/* Bound the given variable of "bset" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_basic_set *isl_basic_set_bound(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  isl_int value, int upper)
+{
+  return bset_from_bmap(basic_map_bound(bset_to_bmap(bset),
+            type, pos, value, upper));
+}
+
+/* Bound the given variable of "bset" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_basic_set *isl_basic_set_bound_val(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  __isl_take isl_val *value, int upper)
+{
+  if (!value)
+    goto error;
+  if (!isl_val_is_int(value))
+    isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+      "expecting integer value", goto error);
+  bset = isl_basic_set_bound(bset, type, pos, value->n, upper);
+  isl_val_free(value);
+  return bset;
+error:
+  isl_val_free(value);
+  isl_basic_set_free(bset);
+  return NULL;
+}
+
+/* Bound the given variable of "bset" from below to "value".
+ */
+__isl_give isl_basic_set *isl_basic_set_lower_bound_val(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  __isl_take isl_val *value)
+{
+  return isl_basic_set_bound_val(bset, type, pos, value, 0);
+}
+
+/* Bound the given variable of "bset" from above to "value".
+ */
+__isl_give isl_basic_set *isl_basic_set_upper_bound_val(
+  __isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+  __isl_take isl_val *value)
+{
+  return isl_basic_set_bound_val(bset, type, pos, value, 1);
+}
+
 __isl_give isl_map *isl_map_reverse(__isl_take isl_map *map)
 {
   int i;
 
   map = isl_map_cow(map);
   if (!map)
     return NULL;
 

 
 __isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
   __isl_take isl_set *set)
 {
   return isl_map_align_params_map_map_and(map, set,
             &map_intersect_domain);
 }
 
+/* Given a map "map" in a space [A -> B] -> C and a map "factor"
+ * in the space B -> C, return the intersection.
+ * The parameters are assumed to have been aligned.
+ *
+ * The map "factor" is first extended to a map living in the space
+ * [A -> B] -> C and then a regular intersection is computed.
+ */
+static __isl_give isl_map *map_intersect_domain_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor)
+{
+  isl_space *space;
+  isl_map *ext_factor;
+
+  space = isl_space_domain_factor_domain(isl_map_get_space(map));
+  ext_factor = isl_map_universe(space);
+  ext_factor = isl_map_domain_product(ext_factor, factor);
+  return map_intersect(map, ext_factor);
+}
+
+/* Given a map "map" in a space [A -> B] -> C and a map "factor"
+ * in the space B -> C, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_domain_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor)
+{
+  return isl_map_align_params_map_map_and(map, factor,
+              &map_intersect_domain_factor_range);
+}
+
+/* Given a map "map" in a space A -> [B -> C] and a map "factor"
+ * in the space A -> C, return the intersection.
+ *
+ * The map "factor" is first extended to a map living in the space
+ * A -> [B -> C] and then a regular intersection is computed.
+ */
+static __isl_give isl_map *map_intersect_range_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor)
+{
+  isl_space *space;
+  isl_map *ext_factor;
+
+  space = isl_space_range_factor_domain(isl_map_get_space(map));
+  ext_factor = isl_map_universe(space);
+  ext_factor = isl_map_range_product(ext_factor, factor);
+  return isl_map_intersect(map, ext_factor);
+}
+
+/* Given a map "map" in a space A -> [B -> C] and a map "factor"
+ * in the space A -> C, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_range_factor_range(
+  __isl_take isl_map *map, __isl_take isl_map *factor)
+{
+  return isl_map_align_params_map_map_and(map, factor,
+              &map_intersect_range_factor_range);
+}
+
 static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
   __isl_take isl_map *map2)
 {
   if (!map1 || !map2)
     goto error;
   map1 = isl_map_reverse(map1);
   map1 = isl_map_apply_range(map1, map2);
   return isl_map_reverse(map1);

  * In other words, plug in "mpa" in "set".
  */
 __isl_give isl_set *isl_set_preimage_multi_pw_aff(__isl_take isl_set *set,
   __isl_take isl_multi_pw_aff *mpa)
 {
   return isl_map_preimage_multi_pw_aff(set, isl_dim_set, mpa);
 }
 
+/* Return a copy of the equality constraints of "bset" as a matrix.
+ */
+__isl_give isl_mat *isl_basic_set_extract_equalities(
+  __isl_keep isl_basic_set *bset)
+{
+  isl_ctx *ctx;
+  unsigned total;
+
+  if (!bset)
+    return NULL;
+
+  ctx = isl_basic_set_get_ctx(bset);
+  total = 1 + isl_basic_set_dim(bset, isl_dim_all);
+  return isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 0, total);
+}
+
 /* Are the "n" "coefficients" starting at "first" of the integer division
  * expressions at position "pos1" in "bmap1" and "pos2" in "bmap2" equal
  * to each other?
  * The "coefficient" at position 0 is the denominator.
  * The "coefficient" at position 1 is the constant term.
  */
 isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
   int pos1, __isl_keep isl_basic_map *bmap2, int pos2,

polly/trunk/lib/External/isl/isl_map_private.h

__isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
   __isl_take isl_basic_map *bmap);
 struct isl_basic_map *isl_basic_map_drop_redundant_divs(
   struct isl_basic_map *bmap);
 
 __isl_give isl_basic_set *isl_basic_set_recession_cone(
   __isl_take isl_basic_set *bset);
 __isl_give isl_basic_set *isl_basic_set_lineality_space(
   __isl_take isl_basic_set *bset);
+__isl_give isl_basic_set *isl_set_combined_lineality_space(
+  __isl_take isl_set *set);
 
 __isl_give isl_basic_set *isl_basic_set_set_integral(
   __isl_take isl_basic_set *bset);
-struct isl_basic_set *isl_basic_set_set_rational(struct isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_set_rational(
+  __isl_take isl_basic_set *bset);
 __isl_give isl_set *isl_set_set_rational(__isl_take isl_set *set);
 __isl_give isl_basic_map *isl_basic_map_set_rational(
   __isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map);
 
 isl_bool isl_map_is_rational(__isl_keep isl_map *map);
 isl_bool isl_set_is_rational(__isl_keep isl_set *set);
 

 isl_bool isl_basic_map_plain_is_non_empty(__isl_keep isl_basic_map *bmap);
 isl_bool isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap);
 
 isl_bool isl_map_is_set(__isl_keep isl_map *map);
 
 isl_bool isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
   unsigned dim, isl_int *val);
 
+__isl_give isl_set *isl_set_plain_gist_basic_set(__isl_take isl_set *set,
+  __isl_take isl_basic_set *context);
 __isl_give isl_map *isl_map_plain_gist_basic_map(__isl_take isl_map *map,
   __isl_take isl_basic_map *context);
+__isl_give isl_map *isl_map_plain_gist(__isl_take isl_map *map,
+  __isl_take isl_map *context);
 
 __isl_give isl_basic_set *isl_basic_set_plain_affine_hull(
   __isl_take isl_basic_set *bset);
 __isl_give isl_basic_map *isl_basic_map_plain_affine_hull(
   __isl_take isl_basic_map *bmap);
 
 isl_stat isl_basic_set_dim_residue_class(__isl_keep isl_basic_set *bset,
   int pos, isl_int *modulo, isl_int *residue);
__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
   __isl_keep isl_map *map);
 
 __isl_give isl_map *isl_map_fixed_power(__isl_take isl_map *map, isl_int exp);
 
 int isl_basic_set_count_upto(__isl_keep isl_basic_set *bset,
   isl_int max, isl_int *count);
 int isl_set_count_upto(__isl_keep isl_set *set, isl_int max, isl_int *count);
 
+__isl_give isl_mat *isl_basic_set_extract_equalities(
+  __isl_keep isl_basic_set *bset);
+
 isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
   int pos1, __isl_keep isl_basic_map *bmap2, int pos2,
   unsigned first, unsigned n);
 isl_bool isl_basic_map_equal_div_expr_except_constant(
   __isl_keep isl_basic_map *bmap1, int pos1,
   __isl_keep isl_basic_map *bmap2, int pos2);
 __isl_give isl_basic_map *isl_basic_map_set_div_expr_constant_num_si_inplace(
   __isl_take isl_basic_map *bmap, int div, int value);
 
 #endif

polly/trunk/lib/External/isl/isl_map_simplify.c

if (map->n > 1)
     ISL_F_CLR(map, ISL_MAP_DISJOINT);
   return map;
 error:
   isl_map_free(map);
   isl_basic_map_free(context);
   return NULL;
 }
 
+/* Remove the constraints in "context" from "set".
+ * If any of the disjuncts in the result turns out to be the universe,
+ * then return this universe.
+ * "context" is assumed to have explicit representations
+ * for all local variables.
+ */
+__isl_give isl_set *isl_set_plain_gist_basic_set(__isl_take isl_set *set,
+  __isl_take isl_basic_set *context)
+{
+  return set_from_map(isl_map_plain_gist_basic_map(set_to_map(set),
+              bset_to_bmap(context)));
+}
+
+/* Remove the constraints in "context" from "map".
+ * If any of the disjuncts in the result turns out to be the universe,
+ * then return this universe.
+ * "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_map *isl_map_plain_gist(__isl_take isl_map *map,
+  __isl_take isl_map *context)
+{
+  isl_basic_map *hull;
+
+  hull = isl_map_unshifted_simple_hull(context);
+  return isl_map_plain_gist_basic_map(map, hull);
+}
+
 /* Replace "map" by a universe map in the same space and free "drop".
  */
 static __isl_give isl_map *replace_by_universe(__isl_take isl_map *map,
   __isl_take isl_map *drop)
 {
   isl_map *res;
 
   res = isl_map_universe(isl_map_get_space(map));
isl_bool isl_map_plain_is_disjoint(__isl_keep isl_map *map1,
   intersect = isl_map_plain_is_equal(map1, map2);
   if (intersect < 0 || intersect)
     return intersect < 0 ? isl_bool_error : isl_bool_false;
 
   return all_pairs(map1, map2, &isl_basic_map_plain_is_disjoint);
 }
 
 /* Are "map1" and "map2" disjoint?
+ * The parameters are assumed to have been aligned.
+ *
+ * In particular, check whether all pairs of basic maps are disjoint.
+ */
+static isl_bool isl_map_is_disjoint_aligned(__isl_keep isl_map *map1,
+  __isl_keep isl_map *map2)
+{
+  return all_pairs(map1, map2, &isl_basic_map_is_disjoint);
+}
+
+/* Are "map1" and "map2" disjoint?
  *
  * They are disjoint if they are "obviously disjoint" or if one of them
  * is empty.  Otherwise, they are not disjoint if one of them is universal.
  * If the two inputs are (obviously) equal and not empty, then they are
  * not disjoint.
  * If none of these cases apply, then check if all pairs of basic maps
- * are disjoint.
+ * are disjoint after aligning the parameters.
  */
 isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
 {
   isl_bool disjoint;
   isl_bool intersect;
 
   disjoint = isl_map_plain_is_disjoint_global(map1, map2);
   if (disjoint < 0 || disjoint)
isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
   intersect = isl_map_plain_is_universe(map2);
   if (intersect < 0 || intersect)
     return intersect < 0 ? isl_bool_error : isl_bool_false;
 
   intersect = isl_map_plain_is_equal(map1, map2);
   if (intersect < 0 || intersect)
     return isl_bool_not(intersect);
 
-  return all_pairs(map1, map2, &isl_basic_map_is_disjoint);
+  return isl_map_align_params_map_map_and_test(map1, map2,
+            &isl_map_is_disjoint_aligned);
 }
 
 /* Are "bmap1" and "bmap2" disjoint?
  *
  * They are disjoint if they are "obviously disjoint" or if one of them
  * is empty.  Otherwise, they are not disjoint if one of them is universal.
  * If none of these cases apply, we compute the intersection and see if
  * the result is empty.

polly/trunk/lib/External/isl/isl_mat.c

static isl_stat check_col(__isl_keep isl_mat *mat, int col)
   if (!mat)
     return isl_stat_error;
   if (col < 0 || col >= mat->n_col)
     isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
       "column out of range", return isl_stat_error);
   return isl_stat_ok;
 }
 
-int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v)
+/* Check that "row" is a valid row position for "mat".
+ */
+static isl_stat check_row(__isl_keep isl_mat *mat, int row)
 {
   if (!mat)
-    return -1;
+    return isl_stat_error;
   if (row < 0 || row >= mat->n_row)
-    isl_die(mat->ctx, isl_error_invalid, "row out of range",
-      return -1);
+    isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
+      "row out of range", return isl_stat_error);
+  return isl_stat_ok;
+}
+
+int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v)
+{
+  if (check_row(mat, row) < 0)
+    return -1;
   if (check_col(mat, col) < 0)
     return -1;
   isl_int_set(*v, mat->row[row][col]);
   return 0;
 }
 
 /* Extract the element at row "row", oolumn "col" of "mat".
  */
 __isl_give isl_val *isl_mat_get_element_val(__isl_keep isl_mat *mat,
   int row, int col)
 {
   isl_ctx *ctx;
 
-  if (!mat)
+  if (check_row(mat, row) < 0)
     return NULL;
-  ctx = isl_mat_get_ctx(mat);
-  if (row < 0 || row >= mat->n_row)
-    isl_die(ctx, isl_error_invalid, "row out of range",
-      return NULL);
   if (check_col(mat, col) < 0)
     return NULL;
+  ctx = isl_mat_get_ctx(mat);
   return isl_val_int_from_isl_int(ctx, mat->row[row][col]);
 }
 
 __isl_give isl_mat *isl_mat_set_element(__isl_take isl_mat *mat,
   int row, int col, isl_int v)
 {
   mat = isl_mat_cow(mat);
-  if (!mat)
-    return NULL;
-  if (row < 0 || row >= mat->n_row)
-    isl_die(mat->ctx, isl_error_invalid, "row out of range",
-      goto error);
+  if (check_row(mat, row) < 0)
+    return isl_mat_free(mat);
   if (check_col(mat, col) < 0)
     return isl_mat_free(mat);
   isl_int_set(mat->row[row][col], v);
   return mat;
-error:
-  isl_mat_free(mat);
-  return NULL;
 }
 
 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
   int row, int col, int v)
 {
   mat = isl_mat_cow(mat);
-  if (!mat)
-    return NULL;
-  if (row < 0 || row >= mat->n_row)
-    isl_die(mat->ctx, isl_error_invalid, "row out of range",
-      goto error);
+  if (check_row(mat, row) < 0)
+    return isl_mat_free(mat);
   if (check_col(mat, col) < 0)
     return isl_mat_free(mat);
   isl_int_set_si(mat->row[row][col], v);
   return mat;
-error:
-  isl_mat_free(mat);
-  return NULL;
 }
 
 /* Replace the element at row "row", column "col" of "mat" by "v".
  */
 __isl_give isl_mat *isl_mat_set_element_val(__isl_take isl_mat *mat,
   int row, int col, __isl_take isl_val *v)
 {
   if (!v)
error:
   if (U) {
     isl_mat_free(*U);
     *U = NULL;
   }
   isl_mat_free(M);
   return NULL;
 }
 
+/* Use row "row" of "mat" to eliminate column "col" from all other rows.
+ */
+static __isl_give isl_mat *eliminate(__isl_take isl_mat *mat, int row, int col)
+{
+  int k, nr, nc;
+  isl_ctx *ctx;
+
+  if (!mat)
+    return NULL;
+
+  ctx = isl_mat_get_ctx(mat);
+  nr = isl_mat_rows(mat);
+  nc = isl_mat_cols(mat);
+
+  for (k = 0; k < nr; ++k) {
+    if (k == row)
+      continue;
+    if (isl_int_is_zero(mat->row[k][col]))
+      continue;
+    mat = isl_mat_cow(mat);
+    if (!mat)
+      return NULL;
+    isl_seq_elim(mat->row[k], mat->row[row], col, nc, NULL);
+    isl_seq_normalize(ctx, mat->row[k], nc);
+  }
+
+  return mat;
+}
+
+/* Perform Gaussian elimination on the rows of "mat", but start
+ * from the final row and the final column.
+ * Any zero rows that result from the elimination are removed.
+ *
+ * In particular, for each column from last to first,
+ * look for the last row with a non-zero coefficient in that column,
+ * move it last (but before other rows moved last in previous steps) and
+ * use it to eliminate the column from the other rows.
+ */
+__isl_give isl_mat *isl_mat_reverse_gauss(__isl_take isl_mat *mat)
+{
+  int k, row, last, nr, nc;
+
+  if (!mat)
+    return NULL;
+
+  nr = isl_mat_rows(mat);
+  nc = isl_mat_cols(mat);
+
+  last = nc - 1;
+  for (row = nr - 1; row >= 0; --row) {
+    for (; last >= 0; --last) {
+      for (k = row; k >= 0; --k)
+        if (!isl_int_is_zero(mat->row[k][last]))
+          break;
+      if (k >= 0)
+        break;
+    }
+    if (last < 0)
+      break;
+    if (k != row)
+      mat = isl_mat_swap_rows(mat, k, row);
+    if (!mat)
+      return NULL;
+    if (isl_int_is_neg(mat->row[row][last]))
+      mat = isl_mat_row_neg(mat, row);
+    mat = eliminate(mat, row, last);
+    if (!mat)
+      return NULL;
+  }
+  mat = isl_mat_drop_rows(mat, 0, row + 1);
+
+  return mat;
+}
+
+/* Negate the lexicographically negative rows of "mat" such that
+ * all rows in the result are lexicographically non-negative.
+ */
+__isl_give isl_mat *isl_mat_lexnonneg_rows(__isl_take isl_mat *mat)
+{
+  int i, nr, nc;
+
+  if (!mat)
+    return NULL;
+
+  nr = isl_mat_rows(mat);
+  nc = isl_mat_cols(mat);
+
+  for (i = 0; i < nr; ++i) {
+    int pos;
+
+    pos = isl_seq_first_non_zero(mat->row[i], nc);
+    if (pos < 0)
+      continue;
+    if (isl_int_is_nonneg(mat->row[i][pos]))
+      continue;
+    mat = isl_mat_row_neg(mat, i);
+    if (!mat)
+      return NULL;
+  }
+
+  return mat;
+}
+
 struct isl_mat *isl_mat_right_kernel(struct isl_mat *mat)
 {
   int i, rank;
   struct isl_mat *U = NULL;
   struct isl_mat *K;
 
   mat = isl_mat_left_hermite(mat, 0, &U, NULL);
   if (!mat || !U)
for (i = 0; i < mat->n_row; ++i) {
     if (!mat)
       return NULL;
     isl_int_neg(mat->row[i][col], mat->row[i][col]);
   }
 
   return mat;
 }
 
+/* Negate row "row" of "mat" and return the result.
+ */
+__isl_give isl_mat *isl_mat_row_neg(__isl_take isl_mat *mat, int row)
+{
+  if (check_row(mat, row) < 0)
+    return isl_mat_free(mat);
+  if (isl_seq_first_non_zero(mat->row[row], mat->n_col) == -1)
+    return mat;
+  mat = isl_mat_cow(mat);
+  if (!mat)
+    return NULL;
+  isl_seq_neg(mat->row[row], mat->row[row], mat->n_col);
+  return mat;
+}
+
 __isl_give isl_mat *isl_mat_unimodular_complete(__isl_take isl_mat *M, int row)
 {
   int r;
   struct isl_mat *H = NULL, *Q = NULL;
 
   if (!M)
     return NULL;
 
error:
   return NULL;
 }
 
 /* Return the gcd of the elements in row "row" of "mat" in *gcd.
  * Return isl_stat_ok on success and isl_stat_error on failure.
  */
 isl_stat isl_mat_row_gcd(__isl_keep isl_mat *mat, int row, isl_int *gcd)
 {
-  if (!mat)
+  if (check_row(mat, row) < 0)
     return isl_stat_error;
 
-  if (row < 0 || row >= mat->n_row)
-    isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
-      "row out of range", return isl_stat_error);
   isl_seq_gcd(mat->row[row], mat->n_col, gcd);
 
   return isl_stat_ok;
 }
 
 void isl_mat_gcd(__isl_keep isl_mat *mat, isl_int *gcd)
 {
   int i;

polly/trunk/lib/External/isl/isl_mat_private.h

 void isl_mat_sub_copy(struct isl_ctx *ctx, isl_int **dst, isl_int **src,
   unsigned n_row, unsigned dst_col, unsigned src_col, unsigned n_col);
 void isl_mat_sub_neg(struct isl_ctx *ctx, isl_int **dst, isl_int **src,
   unsigned n_row, unsigned dst_col, unsigned src_col, unsigned n_col);
 isl_stat isl_mat_sub_transform(isl_int **row, unsigned n_row,
   unsigned first_col, __isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_diag(isl_ctx *ctx, unsigned n_row, isl_int d);
 
+__isl_give isl_mat *isl_mat_reverse_gauss(__isl_take isl_mat *mat);
+
 __isl_give isl_mat *isl_mat_scale(__isl_take isl_mat *mat, isl_int m);
 __isl_give isl_mat *isl_mat_scale_down_row(__isl_take isl_mat *mat, int row,
   isl_int m);
 
 __isl_give isl_vec *isl_mat_get_row(__isl_keep isl_mat *mat, unsigned row);
 
+__isl_give isl_mat *isl_mat_lexnonneg_rows(__isl_take isl_mat *mat);
+
 int isl_mat_is_scaled_identity(__isl_keep isl_mat *mat);
 
 isl_stat isl_mat_row_gcd(__isl_keep isl_mat *mat, int row, isl_int *gcd);
 
 void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col);
 void isl_mat_col_submul(struct isl_mat *mat,
       int dst_col, isl_int f, int src_col);
 __isl_give isl_mat *isl_mat_col_addmul(__isl_take isl_mat *mat, int dst_col,
   isl_int f, int src_col);
 __isl_give isl_mat *isl_mat_col_neg(__isl_take isl_mat *mat, int col);
+__isl_give isl_mat *isl_mat_row_neg(__isl_take isl_mat *mat, int row);
 
 int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v);
 __isl_give isl_mat *isl_mat_set_element(__isl_take isl_mat *mat,
   int row, int col, isl_int v);

polly/trunk/lib/External/isl/isl_maybe_map.h

+#ifndef ISL_MAYBE_MAP_H
+#define ISL_MAYBE_MAP_H
+
+#include <isl/map_type.h>
+
+#define ISL_TYPE  isl_map
+#include <isl/maybe_templ.h>
+#undef ISL_TYPE
+
+#endif

polly/trunk/lib/External/isl/isl_options.c

ISL_ARG_BOOL(struct isl_options, schedule_separate_components, 0,
   "schedule-separate-components", 1,
   "separate components in dependence graph")
 ISL_ARG_BOOL(struct isl_options, schedule_whole_component, 0,
   "schedule-whole-component", 1,
   "try and compute schedule for entire component first")
 ISL_ARG_CHOICE(struct isl_options, schedule_algorithm, 0,
   "schedule-algorithm", isl_schedule_algorithm_choice,
   ISL_SCHEDULE_ALGORITHM_ISL, "scheduling algorithm to use")
+ISL_ARG_BOOL(struct isl_options, schedule_carry_self_first, 0,
+  "schedule-carry-self-first", 1, "try and carry self-dependences first")
 ISL_ARG_BOOL(struct isl_options, schedule_serialize_sccs, 0,
   "schedule-serialize-sccs", 0,
   "serialize strongly connected components in dependence graph")
 ISL_ARG_PHANTOM_USER_CHOICE_F(0, "schedule-fuse", fuse, &set_fuse,
   ISL_SCHEDULE_FUSE_MAX, "level of fusion during scheduling",
   ISL_ARG_HIDDEN)
 ISL_ARG_BOOL(struct isl_options, tile_scale_tile_loops, 0,
   "tile-scale-tile-loops", 1, "scale tile loops")
ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
   schedule_outer_coincidence)
 
 ISL_CTX_SET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
   schedule_algorithm)
 ISL_CTX_GET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
   schedule_algorithm)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+  schedule_carry_self_first)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+  schedule_carry_self_first)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
   schedule_serialize_sccs)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
   schedule_serialize_sccs)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
   tile_scale_tile_loops)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
   tile_scale_tile_loops)

polly/trunk/lib/External/isl/isl_options_private.h

struct isl_options {
   int     schedule_outer_coincidence;
   int     schedule_maximize_band_depth;
   int     schedule_maximize_coincidence;
   int     schedule_split_scaled;
   int     schedule_treat_coalescing;
   int     schedule_separate_components;
   int     schedule_whole_component;
   unsigned    schedule_algorithm;
+  int     schedule_carry_self_first;
   int     schedule_serialize_sccs;
 
   int     tile_scale_tile_loops;
   int     tile_shift_point_loops;
 
   char      *ast_iterator_type;
   int     ast_always_print_block;
   int     ast_print_macro_once;

polly/trunk/lib/External/isl/isl_schedule_constraints.c

 /*
  * Copyright 2012      Ecole Normale Superieure
  * Copyright 2015-2016 Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege,
  * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
  */
 
-#include <string.h>
-
 #include <isl_schedule_constraints.h>
 #include <isl/schedule.h>
 #include <isl/set.h>
 #include <isl/map.h>
 #include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl/stream.h>
 
__isl_give isl_printer *isl_printer_print_schedule_constraints(
 
   return p;
 }
 
 #undef BASE
 #define BASE schedule_constraints
 #include <print_templ_yaml.c>
 
-/* Extract a mapping key from the token "tok".
- * Return isl_sc_key_error on error, i.e., if "tok" does not
- * correspond to any known key.
- */
-static enum isl_sc_key extract_key(__isl_keep isl_stream *s,
-  struct isl_token *tok)
-{
-  int type;
-  char *name;
-  isl_ctx *ctx;
-  enum isl_sc_key key;
-
-  if (!tok)
-    return isl_sc_key_error;
-  type = isl_token_get_type(tok);
-  if (type != ISL_TOKEN_IDENT && type != ISL_TOKEN_STRING) {
-    isl_stream_error(s, tok, "expecting key");
-    return isl_sc_key_error;
-  }
-
-  ctx = isl_stream_get_ctx(s);
-  name = isl_token_get_str(ctx, tok);
-  if (!name)
-    return isl_sc_key_error;
-
-  for (key = 0; key < isl_sc_key_end; ++key) {
-    if (!strcmp(name, key_str[key]))
-      break;
-  }
-  free(name);
-
-  if (key >= isl_sc_key_end)
-    isl_die(ctx, isl_error_invalid, "unknown key",
-      return isl_sc_key_error);
-  return key;
-}
-
-/* Read a key from "s" and return the corresponding enum.
- * Return isl_sc_key_error on error, i.e., if the first token
- * on the stream does not correspond to any known key.
- */
-static enum isl_sc_key get_key(__isl_keep isl_stream *s)
-{
-  struct isl_token *tok;
-  enum isl_sc_key key;
-
-  tok = isl_stream_next_token(s);
-  key = extract_key(s, tok);
-  isl_token_free(tok);
-
-  return key;
-}
+#undef KEY
+#define KEY enum isl_sc_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_sc_key_error
+#undef KEY_END
+#define KEY_END isl_sc_key_end
+#include "extract_key.c"
 
 #undef BASE
 #define BASE set
 #include "read_in_string_templ.c"
 
 #undef BASE
 #define BASE union_set
 #include "read_in_string_templ.c"

polly/trunk/lib/External/isl/isl_schedule_read.c

-#include <string.h>
-
 #include <isl/schedule.h>
 #include <isl/stream.h>
 #include <isl_schedule_private.h>
 #include <isl_schedule_tree.h>
 
 /* An enumeration of the various keys that may appear in a YAML mapping
  * of a schedule.
  */
enum isl_schedule_key {
   isl_schedule_key_filter,
   isl_schedule_key_guard,
   isl_schedule_key_leaf,
   isl_schedule_key_mark,
   isl_schedule_key_options,
   isl_schedule_key_permutable,
   isl_schedule_key_schedule,
   isl_schedule_key_sequence,
-  isl_schedule_key_set
+  isl_schedule_key_set,
+  isl_schedule_key_end
 };
 
-/* Extract a mapping key from the token "tok".
- * Return isl_schedule_key_error on error, i.e., if "tok" does not
- * correspond to any known key.
- */
-static enum isl_schedule_key extract_key(__isl_keep isl_stream *s,
-  struct isl_token *tok)
-{
-  int type;
-  char *name;
-  enum isl_schedule_key key;
-  isl_ctx *ctx;
-
-  ctx = isl_stream_get_ctx(s);
-  type = isl_token_get_type(tok);
-  if (type != ISL_TOKEN_IDENT && type != ISL_TOKEN_STRING) {
-    isl_stream_error(s, tok, "expecting key");
-    return isl_schedule_key_error;
-  }
-  name = isl_token_get_str(ctx, tok);
-  if (!strcmp(name, "child"))
-    key = isl_schedule_key_child;
-  else if (!strcmp(name, "coincident"))
-    key = isl_schedule_key_coincident;
-  else if (!strcmp(name, "context"))
-    key = isl_schedule_key_context;
-  else if (!strcmp(name, "contraction"))
-    key = isl_schedule_key_contraction;
-  else if (!strcmp(name, "domain"))
-    key = isl_schedule_key_domain;
-  else if (!strcmp(name, "expansion"))
-    key = isl_schedule_key_expansion;
-  else if (!strcmp(name, "extension"))
-    key = isl_schedule_key_extension;
-  else if (!strcmp(name, "filter"))
-    key = isl_schedule_key_filter;
-  else if (!strcmp(name, "guard"))
-    key = isl_schedule_key_guard;
-  else if (!strcmp(name, "leaf"))
-    key = isl_schedule_key_leaf;
-  else if (!strcmp(name, "mark"))
-    key = isl_schedule_key_mark;
-  else if (!strcmp(name, "options"))
-    key = isl_schedule_key_options;
-  else if (!strcmp(name, "schedule"))
-    key = isl_schedule_key_schedule;
-  else if (!strcmp(name, "sequence"))
-    key = isl_schedule_key_sequence;
-  else if (!strcmp(name, "set"))
-    key = isl_schedule_key_set;
-  else if (!strcmp(name, "permutable"))
-    key = isl_schedule_key_permutable;
-  else
-    isl_die(ctx, isl_error_invalid, "unknown key",
-      key = isl_schedule_key_error);
-  free(name);
-  return key;
-}
-
-/* Read a key from "s" and return the corresponding enum.
- * Return isl_schedule_key_error on error, i.e., if the first token
- * on the stream does not correspond to any known key.
+/* Textual representations of the YAML keys for an isl_schedule object.
  */
-static enum isl_schedule_key get_key(__isl_keep isl_stream *s)
-{
-  struct isl_token *tok;
-  enum isl_schedule_key key;
-
-  tok = isl_stream_next_token(s);
-  key = extract_key(s, tok);
-  isl_token_free(tok);
+static char *key_str[] = {
+  [isl_schedule_key_child] = "child",
+  [isl_schedule_key_coincident] = "coincident",
+  [isl_schedule_key_context] = "context",
+  [isl_schedule_key_contraction] = "contraction",
+  [isl_schedule_key_domain] = "domain",
+  [isl_schedule_key_expansion] = "expansion",
+  [isl_schedule_key_extension] = "extension",
+  [isl_schedule_key_filter] = "filter",
+  [isl_schedule_key_guard] = "guard",
+  [isl_schedule_key_leaf] = "leaf",
+  [isl_schedule_key_mark] = "mark",
+  [isl_schedule_key_options] = "options",
+  [isl_schedule_key_permutable] = "permutable",
+  [isl_schedule_key_schedule] = "schedule",
+  [isl_schedule_key_sequence] = "sequence",
+  [isl_schedule_key_set] = "set",
+};
 
-  return key;
-}
+#undef KEY
+#define KEY enum isl_schedule_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_schedule_key_error
+#undef KEY_END
+#define KEY_END isl_schedule_key_end
+#include "extract_key.c"
 
 static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
   __isl_keep isl_stream *s);
 
 /* Read a subtree with context root node from "s".
  */
 static __isl_give isl_schedule_tree *read_context(__isl_keep isl_stream *s)
 {
static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
   case isl_schedule_key_coincident:
   case isl_schedule_key_options:
   case isl_schedule_key_permutable:
     tree = read_band(s);
     break;
   case isl_schedule_key_child:
     isl_die(isl_stream_get_ctx(s), isl_error_unsupported,
       "cannot identity node type", return NULL);
+  case isl_schedule_key_end:
   case isl_schedule_key_error:
     return NULL;
   }
 
   if (isl_stream_yaml_read_end_mapping(s) < 0) {
     isl_stream_error(s, NULL, "unexpected extra elements");
     return isl_schedule_tree_free(tree);
   }

polly/trunk/lib/External/isl/isl_scheduler.c

 #include <isl/hash.h>
 #include <isl/constraint.h>
 #include <isl/schedule.h>
 #include <isl_schedule_constraints.h>
 #include <isl/schedule_node.h>
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 #include <isl/set.h>
-#include <isl/union_set.h>
+#include <isl_union_set_private.h>
 #include <isl_seq.h>
 #include <isl_tab.h>
 #include <isl_dim_map.h>
 #include <isl/map_to_basic_set.h>
 #include <isl_sort.h>
 #include <isl_options_private.h>
 #include <isl_tarjan.h>
 #include <isl_morph.h>

  * sched is a matrix representation of the schedule being constructed
  *  for this node; if compressed is set, then this schedule is
  *  defined over the compressed domain space
  * sched_map is an isl_map representation of the same (partial) schedule
  *  sched_map may be NULL; if compressed is set, then this map
  *  is defined over the uncompressed domain space
  * rank is the number of linearly independent rows in the linear part
  *  of sched
- * the columns of cmap represent a change of basis for the schedule
- *  coefficients; the first rank columns span the linear part of
- *  the schedule rows
- * cinv is the inverse of cmap.
- * ctrans is the transpose of cmap.
+ * the rows of "vmap" represent a change of basis for the node
+ *  variables; the first rank rows span the linear part of
+ *  the schedule rows; the remaining rows are linearly independent
+ * the rows of "indep" represent linear combinations of the schedule
+ * coefficients that are non-zero when the schedule coefficients are
+ * linearly independent of previously computed schedule rows.
  * start is the first variable in the LP problem in the sequences that
  *  represents the schedule coefficients of this node
  * nvar is the dimension of the domain
  * nparam is the number of parameters or 0 if we are not constructing
  *  a parametric schedule
  *
  * If compressed is set, then hull represents the constraints
  * that were used to derive the compression, while compress and

  * "sizes" contains the sizes of the (compressed) instance set
  * in each direction.  If there is no fixed size in a given direction,
  * then the corresponding size value is set to infinity.
  * If the schedule_treat_coalescing option or the schedule_max_coefficient
  * option is set, then "max" contains the maximal values for
  * schedule coefficients of the (compressed) variables.  If no bound
  * needs to be imposed on a particular variable, then the corresponding
  * value is negative.
+ * If not NULL, then "bounds" contains a non-parametric set
+ * in the compressed space that is bounded by the size in each direction.
  */
 struct isl_sched_node {
   isl_space *space;
   int compressed;
   isl_set *hull;
   isl_multi_aff *compress;
   isl_multi_aff *decompress;
   isl_mat *sched;
   isl_map *sched_map;
   int  rank;
-  isl_mat *cmap;
-  isl_mat *cinv;
-  isl_mat *ctrans;
+  isl_mat *indep;
+  isl_mat *vmap;
   int  start;
   int  nvar;
   int  nparam;
 
   int  scc;
   int  cluster;
 
   int *coincident;
 
   isl_multi_val *sizes;
+  isl_basic_set *bounds;
   isl_vec *max;
 };
 
 static int node_has_tuples(const void *entry, const void *val)
 {
   struct isl_sched_node *node = (struct isl_sched_node *)entry;
   isl_space *space = (isl_space *) val;
 

 {
   return is_type(edge, isl_edge_conditional_validity);
 }
 
 /* Internal information about the dependence graph used during
  * the construction of the schedule.
  *
  * intra_hmap is a cache, mapping dependence relations to their dual,
- *  for dependences from a node to itself
+ *  for dependences from a node to itself, possibly without
+ *  coefficients for the parameters
+ * intra_hmap_param is a cache, mapping dependence relations to their dual,
+ *  for dependences from a node to itself, including coefficients
+ *  for the parameters
  * inter_hmap is a cache, mapping dependence relations to their dual,
  *  for dependences between distinct nodes
  * if compression is involved then the key for these maps
  * is the original, uncompressed dependence relation, while
  * the value is the dual of the compressed dependence relation.
  *
  * n is the number of nodes
  * node is the list of nodes

  * scc represents the number of components
  * weak is set if the components are weakly connected
  *
  * max_weight is used during clustering and represents the maximal
  * weight of the relevant proximity edges.
  */
 struct isl_sched_graph {
   isl_map_to_basic_set *intra_hmap;
+  isl_map_to_basic_set *intra_hmap_param;
   isl_map_to_basic_set *inter_hmap;
 
   struct isl_sched_node *node;
   int n;
   int maxvar;
   int max_row;
   int n_row;
 
   int *sorted;
 
   int n_total_row;
   int band_start;
 
   int root;
 
   struct isl_sched_edge *edge;
   int n_edge;
   int max_edge[isl_edge_last + 1];
   struct isl_hash_table *edge_table[isl_edge_last + 1];
 
   struct isl_hash_table *node_table;
-  struct isl_region *region;
+  struct isl_trivial_region *region;
 
   isl_basic_set *lp;
 
   int src_scc;
   int dst_scc;
 
   int scc;
   int weak;
static int graph_alloc(isl_ctx *ctx, struct isl_sched_graph *graph,
   int n_node, int n_edge)
 {
   int i;
 
   graph->n = n_node;
   graph->n_edge = n_edge;
   graph->node = isl_calloc_array(ctx, struct isl_sched_node, graph->n);
   graph->sorted = isl_calloc_array(ctx, int, graph->n);
-  graph->region = isl_alloc_array(ctx, struct isl_region, graph->n);
+  graph->region = isl_alloc_array(ctx,
+          struct isl_trivial_region, graph->n);
   graph->edge = isl_calloc_array(ctx,
           struct isl_sched_edge, graph->n_edge);
 
   graph->intra_hmap = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
+  graph->intra_hmap_param = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
   graph->inter_hmap = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
 
   if (!graph->node || !graph->region || (graph->n_edge && !graph->edge) ||
       !graph->sorted)
     return -1;
 
   for(i = 0; i < graph->n; ++i)
     graph->sorted[i] = i;
 
   return 0;
 }
 
 static void graph_free(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
   int i;
 
   isl_map_to_basic_set_free(graph->intra_hmap);
+  isl_map_to_basic_set_free(graph->intra_hmap_param);
   isl_map_to_basic_set_free(graph->inter_hmap);
 
   if (graph->node)
     for (i = 0; i < graph->n; ++i) {
       isl_space_free(graph->node[i].space);
       isl_set_free(graph->node[i].hull);
       isl_multi_aff_free(graph->node[i].compress);
       isl_multi_aff_free(graph->node[i].decompress);
       isl_mat_free(graph->node[i].sched);
       isl_map_free(graph->node[i].sched_map);
-      isl_mat_free(graph->node[i].cmap);
-      isl_mat_free(graph->node[i].cinv);
-      isl_mat_free(graph->node[i].ctrans);
+      isl_mat_free(graph->node[i].indep);
+      isl_mat_free(graph->node[i].vmap);
       if (graph->root)
         free(graph->node[i].coincident);
       isl_multi_val_free(graph->node[i].sizes);
+      isl_basic_set_free(graph->node[i].bounds);
       isl_vec_free(graph->node[i].max);
     }
   free(graph->node);
   free(graph->sorted);
   if (graph->edge)
     for (i = 0; i < graph->n_edge; ++i) {
       isl_map_free(graph->edge[i].map);
       isl_union_map_free(graph->edge[i].tagged_condition);
static isl_stat set_max_coefficient(isl_ctx *ctx, struct isl_sched_node *node)
   if (!node->max)
     return isl_stat_error;
 
   return isl_stat_ok;
 }
 
 /* Set the entries of node->max to the minimum of the schedule_max_coefficient
  * option (if set) and half of the minimum of the sizes in the other
- * dimensions.  If the minimum of the sizes is one, half of the size
- * is zero and this value is reset to one.
+ * dimensions.  Round up when computing the half such that
+ * if the minimum of the sizes is one, half of the size is taken to be one
+ * rather than zero.
  * If the global minimum is unbounded (i.e., if both
  * the schedule_max_coefficient is not set and the sizes in the other
  * dimensions are unbounded), then store a negative value.
  * If the schedule coefficient is close to the size of the instance set
  * in another dimension, then the schedule may represent a loop
  * coalescing transformation (especially if the coefficient
  * in that other dimension is one).  Forcing the coefficient to be
  * smaller than or equal to half the minimal size should avoid this
for (j = 0; j < node->nvar; ++j) {
         continue;
       if (isl_int_is_neg(v->el[j]) ||
           isl_int_gt(v->el[j], size->n))
         isl_int_set(v->el[j], size->n);
     }
     isl_val_free(size);
   }
 
-  for (i = 0; i < node->nvar; ++i) {
-    isl_int_fdiv_q_ui(v->el[i], v->el[i], 2);
-    if (isl_int_is_zero(v->el[i]))
-      isl_int_set_si(v->el[i], 1);
-  }
+  for (i = 0; i < node->nvar; ++i)
+    isl_int_cdiv_q_ui(v->el[i], v->el[i], 2);
 
   node->max = v;
   return isl_stat_ok;
 error:
   isl_vec_free(v);
   return isl_stat_error;
 }
 

 
 /* Sort the elements of graph->sorted according to the corresponding SCCs.
  */
 static int sort_sccs(struct isl_sched_graph *graph)
 {
   return isl_sort(graph->sorted, graph->n, sizeof(int), &cmp_scc, graph);
 }
 
+/* Return a non-parametric set in the compressed space of "node" that is
+ * bounded by the size in each direction
+ *
+ *  { [x] : -S_i <= x_i <= S_i }
+ *
+ * If S_i is infinity in direction i, then there are no constraints
+ * in that direction.
+ *
+ * Cache the result in node->bounds.
+ */
+static __isl_give isl_basic_set *get_size_bounds(struct isl_sched_node *node)
+{
+  isl_space *space;
+  isl_basic_set *bounds;
+  int i;
+  unsigned nparam;
+
+  if (node->bounds)
+    return isl_basic_set_copy(node->bounds);
+
+  if (node->compressed)
+    space = isl_multi_aff_get_domain_space(node->decompress);
+  else
+    space = isl_space_copy(node->space);
+  nparam = isl_space_dim(space, isl_dim_param);
+  space = isl_space_drop_dims(space, isl_dim_param, 0, nparam);
+  bounds = isl_basic_set_universe(space);
+
+  for (i = 0; i < node->nvar; ++i) {
+    isl_val *size;
+
+    size = isl_multi_val_get_val(node->sizes, i);
+    if (!size)
+      return isl_basic_set_free(bounds);
+    if (!isl_val_is_int(size)) {
+      isl_val_free(size);
+      continue;
+    }
+    bounds = isl_basic_set_upper_bound_val(bounds, isl_dim_set, i,
+              isl_val_copy(size));
+    bounds = isl_basic_set_lower_bound_val(bounds, isl_dim_set, i,
+              isl_val_neg(size));
+  }
+
+  node->bounds = isl_basic_set_copy(bounds);
+  return bounds;
+}
+
+/* Drop some constraints from "delta" that could be exploited
+ * to construct loop coalescing schedules.
+ * In particular, drop those constraint that bound the difference
+ * to the size of the domain.
+ * First project out the parameters to improve the effectiveness.
+ */
+static __isl_give isl_set *drop_coalescing_constraints(
+  __isl_take isl_set *delta, struct isl_sched_node *node)
+{
+  unsigned nparam;
+  isl_basic_set *bounds;
+
+  bounds = get_size_bounds(node);
+
+  nparam = isl_set_dim(delta, isl_dim_param);
+  delta = isl_set_project_out(delta, isl_dim_param, 0, nparam);
+  delta = isl_set_remove_divs(delta);
+  delta = isl_set_plain_gist_basic_set(delta, bounds);
+  return delta;
+}
+
 /* Given a dependence relation R from "node" to itself,
  * construct the set of coefficients of valid constraints for elements
  * in that dependence relation.
  * In particular, the result contains tuples of coefficients
  * c_0, c_n, c_x such that
  *
  *  c_0 + c_n n + c_x y - c_x x >= 0 for each (x,y) in R
  *
  * or, equivalently,
  *
  *  c_0 + c_n n + c_x d >= 0 for each d in delta R = { y - x | (x,y) in R }
  *
  * We choose here to compute the dual of delta R.
  * Alternatively, we could have computed the dual of R, resulting
  * in a set of tuples c_0, c_n, c_x, c_y, and then
  * plugged in (c_0, c_n, c_x, -c_x).
  *
+ * If "need_param" is set, then the resulting coefficients effectively
+ * include coefficients for the parameters c_n.  Otherwise, they may
+ * have been projected out already.
+ * Since the constraints may be different for these two cases,
+ * they are stored in separate caches.
+ * In particular, if no parameter coefficients are required and
+ * the schedule_treat_coalescing option is set, then the parameters
+ * are projected out and some constraints that could be exploited
+ * to construct coalescing schedules are removed before the dual
+ * is computed.
+ *
  * If "node" has been compressed, then the dependence relation
  * is also compressed before the set of coefficients is computed.
  */
 static __isl_give isl_basic_set *intra_coefficients(
   struct isl_sched_graph *graph, struct isl_sched_node *node,
-  __isl_take isl_map *map)
+  __isl_take isl_map *map, int need_param)
 {
+  isl_ctx *ctx;
   isl_set *delta;
   isl_map *key;
   isl_basic_set *coef;
   isl_maybe_isl_basic_set m;
+  isl_map_to_basic_set **hmap = &graph->intra_hmap;
+  int treat;
 
-  m = isl_map_to_basic_set_try_get(graph->intra_hmap, map);
+  if (!map)
+    return NULL;
+
+  ctx = isl_map_get_ctx(map);
+  treat = !need_param && isl_options_get_schedule_treat_coalescing(ctx);
+  if (!treat)
+    hmap = &graph->intra_hmap_param;
+  m = isl_map_to_basic_set_try_get(*hmap, map);
   if (m.valid < 0 || m.valid) {
     isl_map_free(map);
     return m.value;
   }
 
   key = isl_map_copy(map);
   if (node->compressed) {
     map = isl_map_preimage_domain_multi_aff(map,
             isl_multi_aff_copy(node->decompress));
     map = isl_map_preimage_range_multi_aff(map,
             isl_multi_aff_copy(node->decompress));
   }
-  delta = isl_set_remove_divs(isl_map_deltas(map));
+  delta = isl_map_deltas(map);
+  if (treat)
+    delta = drop_coalescing_constraints(delta, node);
+  delta = isl_set_remove_divs(delta);
   coef = isl_set_coefficients(delta);
-  graph->intra_hmap = isl_map_to_basic_set_set(graph->intra_hmap, key,
-          isl_basic_set_copy(coef));
+  *hmap = isl_map_to_basic_set_set(*hmap, key, isl_basic_set_copy(coef));
 
   return coef;
 }
 
 /* Given a dependence relation R, construct the set of coefficients
  * of valid constraints for elements in that dependence relation.
  * In particular, the result contains tuples of coefficients
  * c_0, c_n, c_x, c_y such that
static int coef_var_offset(__isl_keep isl_basic_set *coef)
 
   space = isl_space_unwrap(isl_basic_set_get_space(coef));
   offset = isl_space_dim(space, isl_dim_in);
   isl_space_free(space);
 
   return offset;
 }
 
-/* Return the offset of the coefficients of the variables of "node"
+/* Return the offset of the coefficient of the constant term of "node"
  * within the (I)LP.
  *
  * Within each node, the coefficients have the following order:
+ *  - positive and negative parts of c_i_x
+ *  - c_i_n (if parametric)
  *  - c_i_0
+ */
+static int node_cst_coef_offset(struct isl_sched_node *node)
+{
+  return node->start + 2 * node->nvar + node->nparam;
+}
+
+/* Return the offset of the coefficients of the parameters of "node"
+ * within the (I)LP.
+ *
+ * Within each node, the coefficients have the following order:
+ *  - positive and negative parts of c_i_x
  *  - c_i_n (if parametric)
+ *  - c_i_0
+ */
+static int node_par_coef_offset(struct isl_sched_node *node)
+{
+  return node->start + 2 * node->nvar;
+}
+
+/* Return the offset of the coefficients of the variables of "node"
+ * within the (I)LP.
+ *
+ * Within each node, the coefficients have the following order:
  *  - positive and negative parts of c_i_x
+ *  - c_i_n (if parametric)
+ *  - c_i_0
  */
 static int node_var_coef_offset(struct isl_sched_node *node)
 {
-  return node->start + 1 + node->nparam;
+  return node->start;
+}
+
+/* Return the position of the pair of variables encoding
+ * coefficient "i" of "node".
+ *
+ * The order of these variable pairs is the opposite of
+ * that of the coefficients, with 2 variables per coefficient.
+ */
+static int node_var_coef_pos(struct isl_sched_node *node, int i)
+{
+  return node_var_coef_offset(node) + 2 * (node->nvar - 1 - i);
 }
 
 /* Construct an isl_dim_map for mapping constraints on coefficients
  * for "node" to the corresponding positions in graph->lp.
  * "offset" is the offset of the coefficients for the variables
  * in the input constraints.
  * "s" is the sign of the mapping.
  *
- * The input constraints are given in terms of the coefficients (c_0, c_n, c_x).
+ * The input constraints are given in terms of the coefficients
+ * (c_0, c_x) or (c_0, c_n, c_x).
  * The mapping produced by this function essentially plugs in
+ * (0, c_i_x^+ - c_i_x^-) if s = 1 and
+ * (0, -c_i_x^+ + c_i_x^-) if s = -1 or
  * (0, 0, c_i_x^+ - c_i_x^-) if s = 1 and
  * (0, 0, -c_i_x^+ + c_i_x^-) if s = -1.
  * In graph->lp, the c_i_x^- appear before their c_i_x^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
  *
  * The caller can extend the mapping to also map the other coefficients
  * (and therefore not plug in 0).
  */
 static __isl_give isl_dim_map *intra_dim_map(isl_ctx *ctx,
   struct isl_sched_graph *graph, struct isl_sched_node *node,
   int offset, int s)
 {
   int pos;
   unsigned total;
   isl_dim_map *dim_map;
 
   if (!node)
     return NULL;
 
   total = isl_basic_set_total_dim(graph->lp);
-  pos = node_var_coef_offset(node);
+  pos = node_var_coef_pos(node, 0);
   dim_map = isl_dim_map_alloc(ctx, total);
-  isl_dim_map_range(dim_map, pos, 2, offset, 1, node->nvar, -s);
-  isl_dim_map_range(dim_map, pos + 1, 2, offset, 1, node->nvar, s);
+  isl_dim_map_range(dim_map, pos, -2, offset, 1, node->nvar, -s);
+  isl_dim_map_range(dim_map, pos + 1, -2, offset, 1, node->nvar, s);
 
   return dim_map;
 }
 
 /* Construct an isl_dim_map for mapping constraints on coefficients
  * for "src" (node i) and "dst" (node j) to the corresponding positions
  * in graph->lp.
  * "offset" is the offset of the coefficients for the variables of "src"
  * in the input constraints.
  * "s" is the sign of the mapping.
  *
  * The input constraints are given in terms of the coefficients
  * (c_0, c_n, c_x, c_y).
  * The mapping produced by this function essentially plugs in
  * (c_j_0 - c_i_0, c_j_n - c_i_n,
  *  -(c_i_x^+ - c_i_x^-), c_j_x^+ - c_j_x^-) if s = 1 and
  * (-c_j_0 + c_i_0, -c_j_n + c_i_n,
  *  c_i_x^+ - c_i_x^-, -(c_j_x^+ - c_j_x^-)) if s = -1.
  * In graph->lp, the c_*^- appear before their c_*^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
  *
  * The caller can further extend the mapping.
  */
 static __isl_give isl_dim_map *inter_dim_map(isl_ctx *ctx,
   struct isl_sched_graph *graph, struct isl_sched_node *src,
   struct isl_sched_node *dst, int offset, int s)
 {
   int pos;
   unsigned total;
   isl_dim_map *dim_map;
 
   if (!src || !dst)
     return NULL;
 
   total = isl_basic_set_total_dim(graph->lp);
   dim_map = isl_dim_map_alloc(ctx, total);
 
-  isl_dim_map_range(dim_map, dst->start, 0, 0, 0, 1, s);
-  isl_dim_map_range(dim_map, dst->start + 1, 1, 1, 1, dst->nparam, s);
-  pos = node_var_coef_offset(dst);
-  isl_dim_map_range(dim_map, pos, 2, offset + src->nvar, 1,
+  pos = node_cst_coef_offset(dst);
+  isl_dim_map_range(dim_map, pos, 0, 0, 0, 1, s);
+  pos = node_par_coef_offset(dst);
+  isl_dim_map_range(dim_map, pos, 1, 1, 1, dst->nparam, s);
+  pos = node_var_coef_pos(dst, 0);
+  isl_dim_map_range(dim_map, pos, -2, offset + src->nvar, 1,
         dst->nvar, -s);
-  isl_dim_map_range(dim_map, pos + 1, 2, offset + src->nvar, 1,
+  isl_dim_map_range(dim_map, pos + 1, -2, offset + src->nvar, 1,
         dst->nvar, s);
 
-  isl_dim_map_range(dim_map, src->start, 0, 0, 0, 1, -s);
-  isl_dim_map_range(dim_map, src->start + 1, 1, 1, 1, src->nparam, -s);
-  pos = node_var_coef_offset(src);
-  isl_dim_map_range(dim_map, pos, 2, offset, 1, src->nvar, s);
-  isl_dim_map_range(dim_map, pos + 1, 2, offset, 1, src->nvar, -s);
+  pos = node_cst_coef_offset(src);
+  isl_dim_map_range(dim_map, pos, 0, 0, 0, 1, -s);
+  pos = node_par_coef_offset(src);
+  isl_dim_map_range(dim_map, pos, 1, 1, 1, src->nparam, -s);
+  pos = node_var_coef_pos(src, 0);
+  isl_dim_map_range(dim_map, pos, -2, offset, 1, src->nvar, s);
+  isl_dim_map_range(dim_map, pos + 1, -2, offset, 1, src->nvar, -s);
 
   return dim_map;
 }
 
 /* Add the constraints from "src" to "dst" using "dim_map",
  * after making sure there is enough room in "dst" for the extra constraints.
  */
 static __isl_give isl_basic_set *add_constraints_dim_map(

 /* Add constraints to graph->lp that force validity for the given
  * dependence from a node i to itself.
  * That is, add constraints that enforce
  *
  *  (c_i_0 + c_i_n n + c_i_x y) - (c_i_0 + c_i_n n + c_i_x x)
  *  = c_i_x (y - x) >= 0
  *
  * for each (x,y) in R.
- * We obtain general constraints on coefficients (c_0, c_n, c_x)
- * of valid constraints for (y - x) and then plug in (0, 0, c_i_x^+ - c_i_x^-),
+ * We obtain general constraints on coefficients (c_0, c_x)
+ * of valid constraints for (y - x) and then plug in (0, c_i_x^+ - c_i_x^-),
  * where c_i_x = c_i_x^+ - c_i_x^-, with c_i_x^+ and c_i_x^- non-negative.
  * In graph->lp, the c_i_x^- appear before their c_i_x^+ counterpart.
- *
- * Actually, we do not construct constraints for the c_i_x themselves,
- * but for the coefficients of c_i_x written as a linear combination
- * of the columns in node->cmap.
+ * Note that the result of intra_coefficients may also contain
+ * parameter coefficients c_n, in which case 0 is plugged in for them as well.
  */
 static isl_stat add_intra_validity_constraints(struct isl_sched_graph *graph,
   struct isl_sched_edge *edge)
 {
   int offset;
   isl_map *map = isl_map_copy(edge->map);
   isl_ctx *ctx = isl_map_get_ctx(map);
   isl_dim_map *dim_map;
   isl_basic_set *coef;
   struct isl_sched_node *node = edge->src;
 
-  coef = intra_coefficients(graph, node, map);
+  coef = intra_coefficients(graph, node, map, 0);
 
   offset = coef_var_offset(coef);
 
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-              offset, isl_mat_copy(node->cmap));
   if (!coef)
     return isl_stat_error;
 
   dim_map = intra_dim_map(ctx, graph, node, offset, 1);
   graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
   return isl_stat_ok;
 }
 
 /* Add constraints to graph->lp that force validity for the given
  * dependence from node i to node j.
  * That is, add constraints that enforce
  *
  *  (c_j_0 + c_j_n n + c_j_x y) - (c_i_0 + c_i_n n + c_i_x x) >= 0
  *
  * for each (x,y) in R.
  * We obtain general constraints on coefficients (c_0, c_n, c_x, c_y)
  * of valid constraints for R and then plug in
  * (c_j_0 - c_i_0, c_j_n - c_i_n, -(c_i_x^+ - c_i_x^-), c_j_x^+ - c_j_x^-),
  * where c_* = c_*^+ - c_*^-, with c_*^+ and c_*^- non-negative.
  * In graph->lp, the c_*^- appear before their c_*^+ counterpart.
- *
- * Actually, we do not construct constraints for the c_*_x themselves,
- * but for the coefficients of c_*_x written as a linear combination
- * of the columns in node->cmap.
  */
 static isl_stat add_inter_validity_constraints(struct isl_sched_graph *graph,
   struct isl_sched_edge *edge)
 {
   int offset;
   isl_map *map;
   isl_ctx *ctx;
   isl_dim_map *dim_map;
   isl_basic_set *coef;
   struct isl_sched_node *src = edge->src;
   struct isl_sched_node *dst = edge->dst;
 
   if (!graph->lp)
     return isl_stat_error;
 
   map = isl_map_copy(edge->map);
   ctx = isl_map_get_ctx(map);
   coef = inter_coefficients(graph, edge, map);
 
   offset = coef_var_offset(coef);
 
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-        offset, isl_mat_copy(src->cmap));
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-        offset + src->nvar, isl_mat_copy(dst->cmap));
   if (!coef)
     return isl_stat_error;
 
   dim_map = inter_dim_map(ctx, graph, src, dst, offset, 1);
 
   edge->start = graph->lp->n_ineq;
   graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
   if (!graph->lp)

  *  c_i_x (y - x) + m_0 + m_n n >= 0
  *
  * for each (x,y) in R.
  * We obtain general constraints on coefficients (c_0, c_n, c_x)
  * of valid constraints for (y - x) and then plug in (m_0, m_n, -s * c_i_x),
  * with each coefficient (except m_0) represented as a pair of non-negative
  * coefficients.
  *
- * Actually, we do not construct constraints for the c_i_x themselves,
- * but for the coefficients of c_i_x written as a linear combination
- * of the columns in node->cmap.
- *
  *
  * If "local" is set, then we add constraints
  *
  *  c_i_x (y - x) <= 0
  *
  * or
  *
  *  -c_i_x (y - x) <= 0
  *
  * instead, forcing the dependence distance to be (less than or) equal to 0.
  * That is, we plug in (0, 0, -s * c_i_x),
+ * intra_coefficients is not required to have c_n in its result when
+ * "local" is set.  If they are missing, then (0, -s * c_i_x) is plugged in.
  * Note that dependences marked local are treated as validity constraints
  * by add_all_validity_constraints and therefore also have
  * their distances bounded by 0 from below.
  */
 static isl_stat add_intra_proximity_constraints(struct isl_sched_graph *graph,
   struct isl_sched_edge *edge, int s, int local)
 {
   int offset;
   unsigned nparam;
   isl_map *map = isl_map_copy(edge->map);
   isl_ctx *ctx = isl_map_get_ctx(map);
   isl_dim_map *dim_map;
   isl_basic_set *coef;
   struct isl_sched_node *node = edge->src;
 
-  coef = intra_coefficients(graph, node, map);
+  coef = intra_coefficients(graph, node, map, !local);
 
   offset = coef_var_offset(coef);
 
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-              offset, isl_mat_copy(node->cmap));
   if (!coef)
     return isl_stat_error;
 
   nparam = isl_space_dim(node->space, isl_dim_param);
   dim_map = intra_dim_map(ctx, graph, node, offset, -s);
 
   if (!local) {
     isl_dim_map_range(dim_map, 1, 0, 0, 0, 1, 1);

  * for each (x,y) in R.
  * We obtain general constraints on coefficients (c_0, c_n, c_x, c_y)
  * of valid constraints for R and then plug in
  * (m_0 - s*c_j_0 + s*c_i_0, m_n - s*c_j_n + s*c_i_n,
  *  s*c_i_x, -s*c_j_x)
  * with each coefficient (except m_0, c_*_0 and c_*_n)
  * represented as a pair of non-negative coefficients.
  *
- * Actually, we do not construct constraints for the c_*_x themselves,
- * but for the coefficients of c_*_x written as a linear combination
- * of the columns in node->cmap.
- *
  *
  * If "local" is set (and s = 1), then we add constraints
  *
  *  (c_j_0 + c_j_n n + c_j_x y) - (c_i_0 + c_i_n n + c_i_x x) <= 0
  *
  * or
  *
  *  -((c_j_0 + c_j_n n + c_j_x y) + (c_i_0 + c_i_n n + c_i_x x)) >= 0
static isl_stat add_inter_proximity_constraints(struct isl_sched_graph *graph,
   isl_basic_set *coef;
   struct isl_sched_node *src = edge->src;
   struct isl_sched_node *dst = edge->dst;
 
   coef = inter_coefficients(graph, edge, map);
 
   offset = coef_var_offset(coef);
 
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-        offset, isl_mat_copy(src->cmap));
-  coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-        offset + src->nvar, isl_mat_copy(dst->cmap));
   if (!coef)
     return isl_stat_error;
 
   nparam = isl_space_dim(src->space, isl_dim_param);
   dim_map = inter_dim_map(ctx, graph, src, dst, offset, -s);
 
   if (!local) {
     isl_dim_map_range(dim_map, 1, 0, 0, 0, 1, 1);
     isl_dim_map_range(dim_map, 4, 2, 1, 1, nparam, -1);
     isl_dim_map_range(dim_map, 5, 2, 1, 1, nparam, 1);
   }
 
   graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
   return isl_stat_ok;
 }
 
+/* Should the distance over "edge" be forced to zero?
+ * That is, is it marked as a local edge?
+ * If "use_coincidence" is set, then coincidence edges are treated
+ * as local edges.
+ */
+static int force_zero(struct isl_sched_edge *edge, int use_coincidence)
+{
+  return is_local(edge) || (use_coincidence && is_coincidence(edge));
+}
+
 /* Add all validity constraints to graph->lp.
  *
  * An edge that is forced to be local needs to have its dependence
  * distances equal to zero.  We take care of bounding them by 0 from below
  * here.  add_all_proximity_constraints takes care of bounding them by 0
  * from above.
  *
  * If "use_coincidence" is set, then we treat coincidence edges as local edges.
  * Otherwise, we ignore them.
  */
 static int add_all_validity_constraints(struct isl_sched_graph *graph,
   int use_coincidence)
 {
   int i;
 
   for (i = 0; i < graph->n_edge; ++i) {
     struct isl_sched_edge *edge = &graph->edge[i];
-    int local;
+    int zero;
 
-    local = is_local(edge) ||
-      (is_coincidence(edge) && use_coincidence);
-    if (!is_validity(edge) && !local)
+    zero = force_zero(edge, use_coincidence);
+    if (!is_validity(edge) && !zero)
       continue;
     if (edge->src != edge->dst)
       continue;
     if (add_intra_validity_constraints(graph, edge) < 0)
       return -1;
   }
 
   for (i = 0; i < graph->n_edge; ++i) {
     struct isl_sched_edge *edge = &graph->edge[i];
-    int local;
+    int zero;
 
-    local = is_local(edge) ||
-      (is_coincidence(edge) && use_coincidence);
-    if (!is_validity(edge) && !local)
+    zero = force_zero(edge, use_coincidence);
+    if (!is_validity(edge) && !zero)
       continue;
     if (edge->src == edge->dst)
       continue;
     if (add_inter_validity_constraints(graph, edge) < 0)
       return -1;
   }
 
   return 0;

  */
 static int add_all_proximity_constraints(struct isl_sched_graph *graph,
   int use_coincidence)
 {
   int i;
 
   for (i = 0; i < graph->n_edge; ++i) {
     struct isl_sched_edge *edge = &graph->edge[i];
-    int local;
+    int zero;
 
-    local = is_local(edge) ||
-      (is_coincidence(edge) && use_coincidence);
-    if (!is_proximity(edge) && !local)
+    zero = force_zero(edge, use_coincidence);
+    if (!is_proximity(edge) && !zero)
       continue;
     if (edge->src == edge->dst &&
-        add_intra_proximity_constraints(graph, edge, 1, local) < 0)
+        add_intra_proximity_constraints(graph, edge, 1, zero) < 0)
       return -1;
     if (edge->src != edge->dst &&
-        add_inter_proximity_constraints(graph, edge, 1, local) < 0)
+        add_inter_proximity_constraints(graph, edge, 1, zero) < 0)
       return -1;
-    if (is_validity(edge) || local)
+    if (is_validity(edge) || zero)
       continue;
     if (edge->src == edge->dst &&
         add_intra_proximity_constraints(graph, edge, -1, 0) < 0)
       return -1;
     if (edge->src != edge->dst &&
         add_inter_proximity_constraints(graph, edge, -1, 0) < 0)
       return -1;
   }
 
   return 0;
 }
 
+/* Normalize the rows of "indep" such that all rows are lexicographically
+ * positive and such that each row contains as many final zeros as possible,
+ * given the choice for the previous rows.
+ * Do this by performing elementary row operations.
+ */
+static __isl_give isl_mat *normalize_independent(__isl_take isl_mat *indep)
+{
+  indep = isl_mat_reverse_gauss(indep);
+  indep = isl_mat_lexnonneg_rows(indep);
+  return indep;
+}
+
 /* Compute a basis for the rows in the linear part of the schedule
  * and extend this basis to a full basis.  The remaining rows
  * can then be used to force linear independence from the rows
  * in the schedule.
  *
  * In particular, given the schedule rows S, we compute
  *
  *  S   = H Q
  *  S U = H
  *
  * with H the Hermite normal form of S.  That is, all but the
  * first rank columns of H are zero and so each row in S is
  * a linear combination of the first rank rows of Q.
- * The matrix Q is then transposed because we will write the
- * coefficients of the next schedule row as a column vector s
- * and express this s as a linear combination s = Q c of the
- * computed basis.
- * Similarly, the matrix U is transposed such that we can
- * compute the coefficients c = U s from a schedule row s.
+ * The matrix Q can be used as a variable transformation
+ * that isolates the directions of S in the first rank rows.
+ * Transposing S U = H yields
+ *
+ *  U^T S^T = H^T
+ *
+ * with all but the first rank rows of H^T zero.
+ * The last rows of U^T are therefore linear combinations
+ * of schedule coefficients that are all zero on schedule
+ * coefficients that are linearly dependent on the rows of S.
+ * At least one of these combinations is non-zero on
+ * linearly independent schedule coefficients.
+ * The rows are normalized to involve as few of the last
+ * coefficients as possible and to have a positive initial value.
  */
-static int node_update_cmap(struct isl_sched_node *node)
+static int node_update_vmap(struct isl_sched_node *node)
 {
   isl_mat *H, *U, *Q;
   int n_row = isl_mat_rows(node->sched);
 
   H = isl_mat_sub_alloc(node->sched, 0, n_row,
             1 + node->nparam, node->nvar);
 
   H = isl_mat_left_hermite(H, 0, &U, &Q);
-  isl_mat_free(node->cmap);
-  isl_mat_free(node->cinv);
-  isl_mat_free(node->ctrans);
-  node->ctrans = isl_mat_copy(Q);
-  node->cmap = isl_mat_transpose(Q);
-  node->cinv = isl_mat_transpose(U);
+  isl_mat_free(node->indep);
+  isl_mat_free(node->vmap);
+  node->vmap = Q;
+  node->indep = isl_mat_transpose(U);
   node->rank = isl_mat_initial_non_zero_cols(H);
+  node->indep = isl_mat_drop_rows(node->indep, 0, node->rank);
+  node->indep = normalize_independent(node->indep);
   isl_mat_free(H);
 
-  if (!node->cmap || !node->cinv || !node->ctrans || node->rank < 0)
+  if (!node->indep || !node->vmap || node->rank < 0)
     return -1;
   return 0;
 }
 
 /* Is "edge" marked as a validity or a conditional validity edge?
  */
 static int is_any_validity(struct isl_sched_edge *edge)
 {

  * If an edge is only marked conditional_validity then it counts
  * as zero since it is only checked afterwards.
  *
  * If "use_coincidence" is set, then we treat coincidence edges as local edges.
  * Otherwise, we ignore them.
  */
 static int edge_multiplicity(struct isl_sched_edge *edge, int use_coincidence)
 {
-  if (is_proximity(edge) || is_local(edge))
-    return 2;
-  if (use_coincidence && is_coincidence(edge))
+  if (is_proximity(edge) || force_zero(edge, use_coincidence))
     return 2;
   if (is_validity(edge))
     return 1;
   return 0;
 }
 
+/* How many times should the constraints in "edge" be counted
+ * as a parametric intra-node constraint?
+ *
+ * Only proximity edges that are not forced zero need
+ * coefficient constraints that include coefficients for parameters.
+ * If the edge is also a validity edge, then only
+ * an upper bound is introduced.  Otherwise, both lower and upper bounds
+ * are introduced.
+ */
+static int parametric_intra_edge_multiplicity(struct isl_sched_edge *edge,
+  int use_coincidence)
+{
+  if (edge->src != edge->dst)
+    return 0;
+  if (!is_proximity(edge))
+    return 0;
+  if (force_zero(edge, use_coincidence))
+    return 0;
+  if (is_validity(edge))
+    return 1;
+  else
+    return 2;
+}
+
+/* Add "f" times the number of equality and inequality constraints of "bset"
+ * to "n_eq" and "n_ineq" and free "bset".
+ */
+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;
+
+  *n_eq += isl_basic_set_n_equality(bset);
+  *n_ineq += isl_basic_set_n_inequality(bset);
+  isl_basic_set_free(bset);
+
+  return isl_stat_ok;
+}
+
 /* Count the number of equality and inequality constraints
  * that will be added for the given map.
  *
+ * The edges that require parameter coefficients are counted separately.
+ *
  * "use_coincidence" is set if we should take into account coincidence edges.
  */
 static isl_stat count_map_constraints(struct isl_sched_graph *graph,
   struct isl_sched_edge *edge, __isl_take isl_map *map,
   int *n_eq, int *n_ineq, int use_coincidence)
 {
+  isl_map *copy;
   isl_basic_set *coef;
   int f = edge_multiplicity(edge, use_coincidence);
+  int fp = parametric_intra_edge_multiplicity(edge, use_coincidence);
 
   if (f == 0) {
     isl_map_free(map);
     return isl_stat_ok;
   }
 
-  if (edge->src == edge->dst)
-    coef = intra_coefficients(graph, edge->src, map);
-  else
+  if (edge->src != edge->dst) {
     coef = inter_coefficients(graph, edge, map);
-  if (!coef)
-    return isl_stat_error;
-  *n_eq += f * isl_basic_set_n_equality(coef);
-  *n_ineq += f * isl_basic_set_n_inequality(coef);
-  isl_basic_set_free(coef);
+    return update_count(coef, f, n_eq, n_ineq);
+  }
+
+  if (fp > 0) {
+    copy = isl_map_copy(map);
+    coef = intra_coefficients(graph, edge->src, copy, 1);
+    if (update_count(coef, fp, n_eq, n_ineq) < 0)
+      goto error;
+  }
+
+  if (f > fp) {
+    copy = isl_map_copy(map);
+    coef = intra_coefficients(graph, edge->src, copy, 0);
+    if (update_count(coef, f - fp, n_eq, n_ineq) < 0)
+      goto error;
+  }
 
+  isl_map_free(map);
   return isl_stat_ok;
+error:
+  isl_map_free(map);
+  return isl_stat_error;
 }
 
 /* Count the number of equality and inequality constraints
  * that will be added to the main lp problem.
  * We count as follows
  * validity   -> 1 (>= 0)
  * validity+proximity -> 2 (>= 0 and upper bound)
  * proximity    -> 2 (lower and upper bound)
static isl_stat count_bound_constant_constraints(isl_ctx *ctx,
   return isl_stat_ok;
 }
 
 /* Add constraints to bound the values of the constant terms in the schedule,
  * if requested by the user.
  *
  * The maximal value of the constant terms is defined by the option
  * "schedule_max_constant_term".
- *
- * Within each node, the coefficients have the following order:
- *  - c_i_0
- *  - c_i_n (if parametric)
- *  - positive and negative parts of c_i_x
  */
 static isl_stat add_bound_constant_constraints(isl_ctx *ctx,
   struct isl_sched_graph *graph)
 {
   int i, k;
   int max;
   int total;
 
   max = isl_options_get_schedule_max_constant_term(ctx);
   if (max == -1)
     return isl_stat_ok;
 
   total = isl_basic_set_dim(graph->lp, isl_dim_set);
 
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[i];
+    int pos;
+
     k = isl_basic_set_alloc_inequality(graph->lp);
     if (k < 0)
       return isl_stat_error;
     isl_seq_clr(graph->lp->ineq[k], 1 + total);
-    isl_int_set_si(graph->lp->ineq[k][1 + node->start], -1);
+    pos = node_cst_coef_offset(node);
+    isl_int_set_si(graph->lp->ineq[k][1 + pos], -1);
     isl_int_set_si(graph->lp->ineq[k][0], max);
   }
 
   return isl_stat_ok;
 }
 
 /* Count the number of constraints that will be added by
  * add_bound_coefficient_constraints and increment *n_eq and *n_ineq

  *
  *  c_n <= max
  *
  * i.e.,
  *
  *  -c_n + max >= 0
  *
  * The variables coefficients are, however, not represented directly.
- * Instead, the variables coefficients c_x are written as a linear
- * combination c_x = cmap c_z of some other coefficients c_z,
- * which are in turn encoded as c_z = c_z^+ - c_z^-.
- * Let a_j be the elements of row i of node->cmap, then
+ * Instead, the variable coefficients c_x are written as differences
+ * c_x = c_x^+ - c_x^-.
+ * That is,
  *
  *  -max_i <= c_x_i <= max_i
  *
  * is encoded as
  *
- *  -max_i <= \sum_j a_j (c_z_j^+ - c_z_j^-) <= max_i
+ *  -max_i <= c_x_i^+ - c_x_i^- <= max_i
  *
  * or
  *
- *  -\sum_j a_j (c_z_j^+ - c_z_j^-) + max_i >= 0
- *  \sum_j a_j (c_z_j^+ - c_z_j^-) + max_i >= 0
+ *  -(c_x_i^+ - c_x_i^-) + max_i >= 0
+ *  c_x_i^+ - c_x_i^- + max_i >= 0
  */
 static isl_stat node_add_coefficient_constraints(isl_ctx *ctx,
   struct isl_sched_graph *graph, struct isl_sched_node *node, int max)
 {
   int i, j, k;
   int total;
   isl_vec *ineq;
 
   total = isl_basic_set_dim(graph->lp, isl_dim_set);
 
   for (j = 0; j < node->nparam; ++j) {
     int dim;
 
     if (max < 0)
       continue;
 
     k = isl_basic_set_alloc_inequality(graph->lp);
     if (k < 0)
       return isl_stat_error;
-    dim = 1 + node->start + 1 + j;
+    dim = 1 + node_par_coef_offset(node) + j;
     isl_seq_clr(graph->lp->ineq[k], 1 + total);
     isl_int_set_si(graph->lp->ineq[k][dim], -1);
     isl_int_set_si(graph->lp->ineq[k][0], max);
   }
 
   ineq = isl_vec_alloc(ctx, 1 + total);
   ineq = isl_vec_clr(ineq);
   if (!ineq)
     return isl_stat_error;
   for (i = 0; i < node->nvar; ++i) {
-    int pos = 1 + node_var_coef_offset(node);
+    int pos = 1 + node_var_coef_pos(node, i);
 
     if (isl_int_is_neg(node->max->el[i]))
       continue;
 
-    for (j = 0; j < node->nvar; ++j) {
-      isl_int_set(ineq->el[pos + 2 * j],
-          node->cmap->row[i][j]);
-      isl_int_neg(ineq->el[pos + 2 * j + 1],
-          node->cmap->row[i][j]);
-    }
+    isl_int_set_si(ineq->el[pos], 1);
+    isl_int_set_si(ineq->el[pos + 1], -1);
     isl_int_set(ineq->el[0], node->max->el[i]);
 
     k = isl_basic_set_alloc_inequality(graph->lp);
     if (k < 0)
       goto error;
     isl_seq_cpy(graph->lp->ineq[k], ineq->el, 1 + total);
 
-    isl_seq_neg(ineq->el + pos, ineq->el + pos, 2 * node->nvar);
+    isl_seq_neg(ineq->el + pos, ineq->el + pos, 2);
     k = isl_basic_set_alloc_inequality(graph->lp);
     if (k < 0)
       goto error;
     isl_seq_cpy(graph->lp->ineq[k], ineq->el, 1 + total);
+
+    isl_seq_clr(ineq->el + pos, 2);
   }
   isl_vec_free(ineq);
 
   return isl_stat_ok;
 error:
   isl_vec_free(ineq);
   return isl_stat_error;
 }
static isl_stat add_sum_constraint(struct isl_sched_graph *graph,
   for (i = 0; i < n; ++i)
     isl_int_set_si(graph->lp->eq[k][1 + first + i], 1);
 
   return isl_stat_ok;
 }
 
 /* Add a constraint to graph->lp that equates the value at position
  * "sum_pos" to the sum of the parameter coefficients of all nodes.
- *
- * Within each node, the coefficients have the following order:
- *  - c_i_0
- *  - c_i_n (if parametric)
- *  - positive and negative parts of c_i_x
  */
 static isl_stat add_param_sum_constraint(struct isl_sched_graph *graph,
   int sum_pos)
 {
   int i, j, k;
   int total;
 
   total = isl_basic_set_dim(graph->lp, isl_dim_set);
 
   k = isl_basic_set_alloc_equality(graph->lp);
   if (k < 0)
     return isl_stat_error;
   isl_seq_clr(graph->lp->eq[k], 1 + total);
   isl_int_set_si(graph->lp->eq[k][1 + sum_pos], -1);
   for (i = 0; i < graph->n; ++i) {
-    int pos = 1 + graph->node[i].start + 1;
+    int pos = 1 + node_par_coef_offset(&graph->node[i]);
 
     for (j = 0; j < graph->node[i].nparam; ++j)
       isl_int_set_si(graph->lp->eq[k][pos + j], 1);
   }
 
   return isl_stat_ok;
 }
 
 /* Add a constraint to graph->lp that equates the value at position
  * "sum_pos" to the sum of the variable coefficients of all nodes.
- *
- * Within each node, the coefficients have the following order:
- *  - c_i_0
- *  - c_i_n (if parametric)
- *  - positive and negative parts of c_i_x
  */
 static isl_stat add_var_sum_constraint(struct isl_sched_graph *graph,
   int sum_pos)
 {
   int i, j, k;
   int total;
 
   total = isl_basic_set_dim(graph->lp, isl_dim_set);

  *
  *  - sum of positive and negative parts of m_n coefficients
  *  - m_0
  *  - sum of all c_n coefficients
  *    (unconstrained when computing non-parametric schedules)
  *  - sum of positive and negative parts of all c_x coefficients
  *  - positive and negative parts of m_n coefficients
  *  - for each node
- *    - c_i_0
+ *    - positive and negative parts of c_i_x, in opposite order
  *    - c_i_n (if parametric)
- *    - positive and negative parts of c_i_x
- *
- * The c_i_x are not represented directly, but through the columns of
- * node->cmap.  That is, the computed values are for variable t_i_x
- * such that c_i_x = Q t_i_x with Q equal to node->cmap.
+ *    - c_i_0
  *
  * The constraints are those from the edges plus two or three equalities
  * to express the sums.
  *
  * If "use_coincidence" is set, then we treat coincidence edges as local edges.
  * Otherwise, we ignore them.
  */
 static isl_stat setup_lp(isl_ctx *ctx, struct isl_sched_graph *graph,
   int use_coincidence)
 {
   int i;
   unsigned nparam;
   unsigned total;
   isl_space *space;
   int parametric;
   int param_pos;
   int n_eq, n_ineq;
 
   parametric = ctx->opt->schedule_parametric;
   nparam = isl_space_dim(graph->node[0].space, isl_dim_param);
   param_pos = 4;
   total = param_pos + 2 * nparam;
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[graph->sorted[i]];
-    if (node_update_cmap(node) < 0)
+    if (node_update_vmap(node) < 0)
       return isl_stat_error;
     node->start = total;
     total += 1 + node->nparam + 2 * node->nvar;
   }
 
   if (count_constraints(graph, &n_eq, &n_ineq, use_coincidence) < 0)
     return isl_stat_error;
   if (count_bound_constant_constraints(ctx, graph, &n_eq, &n_ineq) < 0)

  * is as large as the number or remaining rows to be computed,
  * all remaining rows need to be non-trivial.
  */
 static int needs_row(struct isl_sched_graph *graph, struct isl_sched_node *node)
 {
   return node->nvar - node->rank >= graph->maxvar - graph->n_row;
 }
 
+/* Construct a non-triviality region with triviality directions
+ * corresponding to the rows of "indep".
+ * The rows of "indep" are expressed in terms of the schedule coefficients c_i,
+ * while the triviality directions are expressed in terms of
+ * pairs of non-negative variables c^+_i - c^-_i, with c^-_i appearing
+ * before c^+_i.  Furthermore,
+ * the pairs of non-negative variables representing the coefficients
+ * are stored in the opposite order.
+ */
+static __isl_give isl_mat *construct_trivial(__isl_keep isl_mat *indep)
+{
+  isl_ctx *ctx;
+  isl_mat *mat;
+  int i, j, n, n_var;
+
+  if (!indep)
+    return NULL;
+
+  ctx = isl_mat_get_ctx(indep);
+  n = isl_mat_rows(indep);
+  n_var = isl_mat_cols(indep);
+  mat = isl_mat_alloc(ctx, n, 2 * n_var);
+  if (!mat)
+    return NULL;
+  for (i = 0; i < n; ++i) {
+    for (j = 0; j < n_var; ++j) {
+      int nj = n_var - 1 - j;
+      isl_int_neg(mat->row[i][2 * nj], indep->row[i][j]);
+      isl_int_set(mat->row[i][2 * nj + 1], indep->row[i][j]);
+    }
+  }
+
+  return mat;
+}
+
 /* Solve the ILP problem constructed in setup_lp.
  * For each node such that all the remaining rows of its schedule
  * need to be non-trivial, we construct a non-triviality region.
  * This region imposes that the next row is independent of previous rows.
- * In particular the coefficients c_i_x are represented by t_i_x
- * variables with c_i_x = Q t_i_x and Q a unimodular matrix such that
- * its first columns span the rows of the previously computed part
- * of the schedule.  The non-triviality region enforces that at least
- * one of the remaining components of t_i_x is non-zero, i.e.,
- * that the new schedule row depends on at least one of the remaining
- * columns of Q.
+ * In particular, the non-triviality region enforces that at least
+ * one of the linear combinations in the rows of node->indep is non-zero.
  */
-static __isl_give isl_vec *solve_lp(struct isl_sched_graph *graph)
+static __isl_give isl_vec *solve_lp(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
   int i;
   isl_vec *sol;
   isl_basic_set *lp;
 
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[i];
-    int skip = node->rank;
-    graph->region[i].pos = node_var_coef_offset(node) + 2 * skip;
+    isl_mat *trivial;
+
+    graph->region[i].pos = node_var_coef_offset(node);
     if (needs_row(graph, node))
-      graph->region[i].len = 2 * (node->nvar - skip);
+      trivial = construct_trivial(node->indep);
     else
-      graph->region[i].len = 0;
+      trivial = isl_mat_zero(ctx, 0, 0);
+    graph->region[i].trivial = trivial;
   }
   lp = isl_basic_set_copy(graph->lp);
   sol = isl_tab_basic_set_non_trivial_lexmin(lp, 2, graph->n,
                graph->region, &check_conflict, graph);
+  for (i = 0; i < graph->n; ++i)
+    isl_mat_free(graph->region[i].trivial);
   return sol;
 }
 
 /* Extract the coefficients for the variables of "node" from "sol".
  *
- * Within each node, the coefficients have the following order:
- *  - c_i_0
- *  - c_i_n (if parametric)
- *  - positive and negative parts of c_i_x
- *
+ * Each schedule coefficient c_i_x is represented as the difference
+ * between two non-negative variables c_i_x^+ - c_i_x^-.
  * The c_i_x^- appear before their c_i_x^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
  *
  * Return c_i_x = c_i_x^+ - c_i_x^-
  */
 static __isl_give isl_vec *extract_var_coef(struct isl_sched_node *node,
   __isl_keep isl_vec *sol)
 {
   int i;
   int pos;
   isl_vec *csol;
 
   if (!sol)
     return NULL;
   csol = isl_vec_alloc(isl_vec_get_ctx(sol), node->nvar);
   if (!csol)
     return NULL;
 
   pos = 1 + node_var_coef_offset(node);
   for (i = 0; i < node->nvar; ++i)
-    isl_int_sub(csol->el[i],
+    isl_int_sub(csol->el[node->nvar - 1 - i],
           sol->el[pos + 2 * i + 1], sol->el[pos + 2 * i]);
 
   return csol;
 }
 
 /* Update the schedules of all nodes based on the given solution
  * of the LP problem.
  * The new row is added to the current band.
  * All possibly negative coefficients are encoded as a difference
  * of two non-negative variables, so we need to perform the subtraction
- * here.  Moreover, if use_cmap is set, then the solution does
- * not refer to the actual coefficients c_i_x, but instead to variables
- * t_i_x such that c_i_x = Q t_i_x and Q is equal to node->cmap.
- * In this case, we then also need to perform this multiplication
- * to obtain the values of c_i_x.
+ * here.
  *
  * If coincident is set, then the caller guarantees that the new
  * row satisfies the coincidence constraints.
  */
 static int update_schedule(struct isl_sched_graph *graph,
-  __isl_take isl_vec *sol, int use_cmap, int coincident)
+  __isl_take isl_vec *sol, int coincident)
 {
   int i, j;
   isl_vec *csol = NULL;
 
   if (!sol)
     goto error;
   if (sol->size == 0)
     isl_die(sol->ctx, isl_error_internal,
       "no solution found", goto error);
   if (graph->n_total_row >= graph->max_row)
     isl_die(sol->ctx, isl_error_internal,
       "too many schedule rows", goto error);
 
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[i];
-    int pos = node->start;
+    int pos;
     int row = isl_mat_rows(node->sched);
 
     isl_vec_free(csol);
     csol = extract_var_coef(node, sol);
     if (!csol)
       goto error;
 
     isl_map_free(node->sched_map);
     node->sched_map = NULL;
     node->sched = isl_mat_add_rows(node->sched, 1);
     if (!node->sched)
       goto error;
-    for (j = 0; j < 1 + node->nparam; ++j)
-      node->sched = isl_mat_set_element(node->sched,
-            row, j, sol->el[1 + pos + j]);
-    if (use_cmap)
-      csol = isl_mat_vec_product(isl_mat_copy(node->cmap),
-               csol);
-    if (!csol)
-      goto error;
+    pos = node_cst_coef_offset(node);
+          row, 0, sol->el[1 + pos]);
+    pos = node_par_coef_offset(node);
+    for (j = 0; j < node->nparam; ++j)
+      node->sched = isl_mat_set_element(node->sched,
+          row, 1 + j, sol->el[1 + pos + j]);
     for (j = 0; j < node->nvar; ++j)
       node->sched = isl_mat_set_element(node->sched,
           row, 1 + node->nparam + j, csol->el[j]);
     node->coincident[graph->n_total_row] = coincident;
   }
   isl_vec_free(sol);
   isl_vec_free(csol);
 
for (i = 0; i < src->n; ++i) {
     dst->node[j].decompress =
       isl_multi_aff_copy(src->node[i].decompress);
     dst->node[j].nvar = src->node[i].nvar;
     dst->node[j].nparam = src->node[i].nparam;
     dst->node[j].sched = isl_mat_copy(src->node[i].sched);
     dst->node[j].sched_map = isl_map_copy(src->node[i].sched_map);
     dst->node[j].coincident = src->node[i].coincident;
     dst->node[j].sizes = isl_multi_val_copy(src->node[i].sizes);
+    dst->node[j].bounds = isl_basic_set_copy(src->node[i].bounds);
     dst->node[j].max = isl_vec_copy(src->node[i].max);
     dst->n++;
 
     if (!dst->node[j].space || !dst->node[j].sched)
       return -1;
     if (dst->node[j].compressed &&
         (!dst->node[j].hull || !dst->node[j].compress ||
          !dst->node[j].decompress))

 {
   int i;
 
   graph->maxvar = 0;
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[i];
     int nvar;
 
-    if (node_update_cmap(node) < 0)
+    if (node_update_vmap(node) < 0)
       return -1;
     nvar = node->nvar + graph->n_row - node->rank;
     if (nvar > graph->maxvar)
       graph->maxvar = nvar;
   }
 
   return 0;
 }
static __isl_give isl_schedule_node *compute_next_band(
   node = isl_schedule_node_parent(node);
 
   return node;
 }
 
 /* Add the constraints "coef" derived from an edge from "node" to itself
  * to graph->lp in order to respect the dependences and to try and carry them.
  * "pos" is the sequence number of the edge that needs to be carried.
- * "coef" represents general constraints on coefficients (c_0, c_n, c_x)
+ * "coef" represents general constraints on coefficients (c_0, c_x)
  * of valid constraints for (y - x) with x and y instances of the node.
  *
  * The constraints added to graph->lp need to enforce
  *
- *  (c_j_0 + c_j_n n + c_j_x y) - (c_j_0 + c_j_n n + c_j_x x)
+ *  (c_j_0 + c_j_x y) - (c_j_0 + c_j_x x)
  *  = c_j_x (y - x) >= e_i
  *
  * for each (x,y) in the dependence relation of the edge.
- * That is, (-e_i, 0, c_j_x) needs to be plugged in for (c_0, c_n, c_x),
+ * That is, (-e_i, c_j_x) needs to be plugged in for (c_0, c_x),
  * taking into account that each coefficient in c_j_x is represented
  * as a pair of non-negative coefficients.
  */
 static isl_stat add_intra_constraints(struct isl_sched_graph *graph,
   struct isl_sched_node *node, __isl_take isl_basic_set *coef, int pos)
 {
   int offset;
   isl_ctx *ctx;
   isl_dim_map *dim_map;
 
   if (!coef)
     return isl_stat_error;
 
   ctx = isl_basic_set_get_ctx(coef);
   offset = coef_var_offset(coef);
   dim_map = intra_dim_map(ctx, graph, node, offset, 1);
   isl_dim_map_range(dim_map, 3 + pos, 0, 0, 0, 1, -1);
   graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
   return isl_stat_ok;
 }
 
 /* Add the constraints "coef" derived from an edge from "src" to "dst"
  * to graph->lp in order to respect the dependences and to try and carry them.
- * "pos" is the sequence number of the edge that needs to be carried.
+ * "pos" is the sequence number of the edge that needs to be carried or
+ * -1 if no attempt should be made to carry the dependences.
  * "coef" represents general constraints on coefficients (c_0, c_n, c_x, c_y)
  * of valid constraints for (x, y) with x and y instances of "src" and "dst".
  *
  * The constraints added to graph->lp need to enforce
  *
  *  (c_k_0 + c_k_n n + c_k_x y) - (c_j_0 + c_j_n n + c_j_x x) >= e_i
  *
- * for each (x,y) in the dependence relation of the edge.
+ * for each (x,y) in the dependence relation of the edge or
+ *
+ *  (c_k_0 + c_k_n n + c_k_x y) - (c_j_0 + c_j_n n + c_j_x x) >= 0
+ *
+ * if pos is -1.
  * That is,
  * (-e_i + c_k_0 - c_j_0, c_k_n - c_j_n, -c_j_x, c_k_x)
+ * or
+ * (c_k_0 - c_j_0, c_k_n - c_j_n, -c_j_x, c_k_x)
  * needs to be plugged in for (c_0, c_n, c_x, c_y),
  * taking into account that each coefficient in c_j_x and c_k_x is represented
  * as a pair of non-negative coefficients.
  */
 static isl_stat add_inter_constraints(struct isl_sched_graph *graph,
   struct isl_sched_node *src, struct isl_sched_node *dst,
   __isl_take isl_basic_set *coef, int pos)
 {
   int offset;
   isl_ctx *ctx;
   isl_dim_map *dim_map;
 
   if (!coef)
     return isl_stat_error;
 
   ctx = isl_basic_set_get_ctx(coef);
   offset = coef_var_offset(coef);
   dim_map = inter_dim_map(ctx, graph, src, dst, offset, 1);
+  if (pos >= 0)
     isl_dim_map_range(dim_map, 3 + pos, 0, 0, 0, 1, -1);
   graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
   return isl_stat_ok;
 }
 
+/* Data structure for keeping track of the data needed
+ * to exploit non-trivial lineality spaces.
+ *
+ * "any_non_trivial" is true if there are any non-trivial lineality spaces.
+ * If "any_non_trivial" is not true, then "equivalent" and "mask" may be NULL.
+ * "equivalent" connects instances to other instances on the same line(s).
+ * "mask" contains the domain spaces of "equivalent".
+ * Any instance set not in "mask" does not have a non-trivial lineality space.
+ */
+struct isl_exploit_lineality_data {
+  isl_bool any_non_trivial;
+  isl_union_map *equivalent;
+  isl_union_set *mask;
+};
+
 /* Data structure collecting information used during the construction
  * of an LP for carrying dependences.
  *
  * "intra" is a sequence of coefficient constraints for intra-node edges.
  * "inter" is a sequence of coefficient constraints for inter-node edges.
+ * "lineality" contains data used to exploit non-trivial lineality spaces.
  */
 struct isl_carry {
   isl_basic_set_list *intra;
   isl_basic_set_list *inter;
+  struct isl_exploit_lineality_data lineality;
 };
 
 /* Free all the data stored in "carry".
  */
 static void isl_carry_clear(struct isl_carry *carry)
 {
   isl_basic_set_list_free(carry->intra);
   isl_basic_set_list_free(carry->inter);
+  isl_union_map_free(carry->lineality.equivalent);
+  isl_union_set_free(carry->lineality.mask);
 }
 
 /* Return a pointer to the node in "graph" that lives in "space".
  * If the requested node has been compressed, then "space"
  * corresponds to the compressed space.
  *
  * First try and see if "space" is the space of an uncompressed node.
  * If so, return that node.
static struct isl_sched_node *graph_find_compressed_node(isl_ctx *ctx,
 
   return node;
 }
 
 /* Internal data structure for add_all_constraints.
  *
  * "graph" is the schedule constraint graph for which an LP problem
  * is being constructed.
+ * "carry_inter" indicates whether inter-node edges should be carried.
  * "pos" is the position of the next edge that needs to be carried.
  */
 struct isl_add_all_constraints_data {
   isl_ctx *ctx;
   struct isl_sched_graph *graph;
+  int carry_inter;
   int pos;
 };
 
 /* Add the constraints "coef" derived from an edge from a node to itself
  * to data->graph->lp in order to respect the dependences and
  * to try and carry them.
  *
  * The space of "coef" is of the form
  *
- *  coefficients[[c_cst, c_n] -> S[c_x]]
+ *  coefficients[[c_cst] -> S[c_x]]
  *
  * with S[c_x] the (compressed) space of the node.
  * Extract the node from the space and call add_intra_constraints.
  */
 static isl_stat lp_add_intra(__isl_take isl_basic_set *coef, void *user)
 {
   struct isl_add_all_constraints_data *data = user;
   isl_space *space;
   struct isl_sched_node *node;
 
   space = isl_basic_set_get_space(coef);
   space = isl_space_range(isl_space_unwrap(space));
   node = graph_find_compressed_node(data->ctx, data->graph, space);
   isl_space_free(space);
   return add_intra_constraints(data->graph, node, coef, data->pos++);
 }
 
 /* Add the constraints "coef" derived from an edge from a node j
  * to a node k to data->graph->lp in order to respect the dependences and
- * to try and carry them.
+ * to try and carry them (provided data->carry_inter is set).
  *
  * The space of "coef" is of the form
  *
  *  coefficients[[c_cst, c_n] -> [S_j[c_x] -> S_k[c_y]]]
  *
  * with S_j[c_x] and S_k[c_y] the (compressed) spaces of the nodes.
  * Extract the nodes from the space and call add_inter_constraints.
  */
 static isl_stat lp_add_inter(__isl_take isl_basic_set *coef, void *user)
 {
   struct isl_add_all_constraints_data *data = user;
   isl_space *space, *dom;
   struct isl_sched_node *src, *dst;
+  int pos;
 
   space = isl_basic_set_get_space(coef);
   space = isl_space_unwrap(isl_space_range(isl_space_unwrap(space)));
   dom = isl_space_domain(isl_space_copy(space));
   src = graph_find_compressed_node(data->ctx, data->graph, dom);
   isl_space_free(dom);
   space = isl_space_range(space);
   dst = graph_find_compressed_node(data->ctx, data->graph, space);
   isl_space_free(space);
 
-  return add_inter_constraints(data->graph, src, dst, coef, data->pos++);
+  pos = data->carry_inter ? data->pos++ : -1;
+  return add_inter_constraints(data->graph, src, dst, coef, pos);
 }
 
 /* Add constraints to graph->lp that force all (conditional) validity
  * dependences to be respected and attempt to carry them.
  * "intra" is the sequence of coefficient constraints for intra-node edges.
  * "inter" is the sequence of coefficient constraints for inter-node edges.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.
  */
 static isl_stat add_all_constraints(isl_ctx *ctx, struct isl_sched_graph *graph,
   __isl_keep isl_basic_set_list *intra,
-  __isl_keep isl_basic_set_list *inter)
+  __isl_keep isl_basic_set_list *inter, int carry_inter)
 {
-  struct isl_add_all_constraints_data data = { ctx, graph };
+  struct isl_add_all_constraints_data data = { ctx, graph, carry_inter };
 
   data.pos = 0;
   if (isl_basic_set_list_foreach(intra, &lp_add_intra, &data) < 0)
     return isl_stat_error;
   if (isl_basic_set_list_foreach(inter, &lp_add_inter, &data) < 0)
     return isl_stat_error;
   return isl_stat_ok;
 }
 
 /* Internal data structure for count_all_constraints
  * for keeping track of the number of equality and inequality constraints.
  */
 struct isl_sched_count {
   int n_eq;
   int n_ineq;
 };
 
 /* Add the number of equality and inequality constraints of "bset"
  * to data->n_eq and data->n_ineq.
  */
 static isl_stat bset_update_count(__isl_take isl_basic_set *bset, void *user)
 {
   struct isl_sched_count *data = user;
 
-  data->n_eq += isl_basic_set_n_equality(bset);
-  data->n_ineq += isl_basic_set_n_inequality(bset);
-  isl_basic_set_free(bset);
-
-  return isl_stat_ok;
+  return update_count(bset, 1, &data->n_eq, &data->n_ineq);
 }
 
 /* Count the number of equality and inequality constraints
  * that will be added to the carry_lp problem.
  * We count each edge exactly once.
  * "intra" is the sequence of coefficient constraints for intra-node edges.
  * "inter" is the sequence of coefficient constraints for inter-node edges.
  */

  * such that the schedule carries as many validity dependences as possible.
  * In particular, for each dependence i, we bound the dependence distance
  * from below by e_i, with 0 <= e_i <= 1 and then maximize the sum
  * of all e_i's.  Dependences with e_i = 0 in the solution are simply
  * respected, while those with e_i > 0 (in practice e_i = 1) are carried.
  * "intra" is the sequence of coefficient constraints for intra-node edges.
  * "inter" is the sequence of coefficient constraints for inter-node edges.
  * "n_edge" is the total number of edges.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.  That is, if "carry_inter" is not set, then
+ * no e_i variables are introduced for the inter-node edges.
  *
  * All variables of the LP are non-negative.  The actual coefficients
  * may be negative, so each coefficient is represented as the difference
  * of two non-negative variables.  The negative part always appears
  * immediately before the positive part.
  * Other than that, the variables have the following order
  *
  *  - sum of (1 - e_i) over all edges
  *  - sum of all c_n coefficients
  *    (unconstrained when computing non-parametric schedules)
  *  - sum of positive and negative parts of all c_x coefficients
  *  - for each edge
  *    - e_i
  *  - for each node
- *    - c_i_0
+ *    - positive and negative parts of c_i_x, in opposite order
  *    - c_i_n (if parametric)
- *    - positive and negative parts of c_i_x
+ *    - c_i_0
  *
  * The constraints are those from the (validity) edges plus three equalities
  * to express the sums and n_edge inequalities to express e_i <= 1.
  */
 static isl_stat setup_carry_lp(isl_ctx *ctx, struct isl_sched_graph *graph,
   int n_edge, __isl_keep isl_basic_set_list *intra,
-  __isl_keep isl_basic_set_list *inter)
+  __isl_keep isl_basic_set_list *inter, int carry_inter)
 {
   int i;
   int k;
   isl_space *dim;
   unsigned total;
   int n_eq, n_ineq;
 
   total = 3 + n_edge;
for (i = 0; i < n_edge; ++i) {
     k = isl_basic_set_alloc_inequality(graph->lp);
     if (k < 0)
       return isl_stat_error;
     isl_seq_clr(graph->lp->ineq[k], 1 + total);
     isl_int_set_si(graph->lp->ineq[k][4 + i], -1);
     isl_int_set_si(graph->lp->ineq[k][0], 1);
   }
 
-  if (add_all_constraints(ctx, graph, intra, inter) < 0)
+  if (add_all_constraints(ctx, graph, intra, inter, carry_inter) < 0)
     return isl_stat_error;
 
   return isl_stat_ok;
 }
 
 static __isl_give isl_schedule_node *compute_component_schedule(
   __isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
   int wcc);
 
-/* Comparison function for sorting the statements based on
- * the corresponding value in "r".
- */
-static int smaller_value(const void *a, const void *b, void *data)
-{
-  isl_vec *r = data;
-  const int *i1 = a;
-  const int *i2 = b;
-
-  return isl_int_cmp(r->el[*i1], r->el[*i2]);
-}
-
 /* If the schedule_split_scaled option is set and if the linear
  * parts of the scheduling rows for all nodes in the graphs have
- * a non-trivial common divisor, then split off the remainder of the
- * constant term modulo this common divisor from the linear part.
+ * a non-trivial common divisor, then remove this
+ * common divisor from the linear part.
  * Otherwise, insert a band node directly and continue with
  * the construction of the schedule.
  *
  * If a non-trivial common divisor is found, then
- * the linear part is reduced and the remainder is enforced
- * by a sequence node with the children placed in the order
- * of this remainder.
- * In particular, we assign an scc index based on the remainder and
- * then rely on compute_component_schedule to insert the sequence and
- * to continue the schedule construction on each part.
+ * the linear part is reduced and the remainder is ignored.
+ * The pieces of the graph that are assigned different remainders
+ * form (groups of) strongly connected components within
+ * the scaled down band.  If needed, they can therefore
+ * be ordered along this remainder in a sequence node.
+ * However, this ordering is not enforced here in order to allow
+ * the scheduler to combine some of the strongly connected components.
  */
 static __isl_give isl_schedule_node *split_scaled(
   __isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
 {
   int i;
   int row;
-  int scc;
   isl_ctx *ctx;
   isl_int gcd, gcd_i;
-  isl_vec *r;
-  int *order;
 
   if (!node)
     return NULL;
 
   ctx = isl_schedule_node_get_ctx(node);
   if (!ctx->opt->schedule_split_scaled)
     return compute_next_band(node, graph, 0);
   if (graph->n <= 1)
static __isl_give isl_schedule_node *split_scaled(
 
   isl_int_clear(gcd_i);
 
   if (isl_int_cmp_si(gcd, 1) <= 0) {
     isl_int_clear(gcd);
     return compute_next_band(node, graph, 0);
   }
 
-  r = isl_vec_alloc(ctx, graph->n);
-  order = isl_calloc_array(ctx, int, graph->n);
-  if (!r || !order)
-    goto error;
-
   for (i = 0; i < graph->n; ++i) {
     struct isl_sched_node *node = &graph->node[i];
 
-    order[i] = i;
-    isl_int_fdiv_r(r->el[i], node->sched->row[row][0], gcd);
     isl_int_fdiv_q(node->sched->row[row][0],
              node->sched->row[row][0], gcd);
     isl_int_mul(node->sched->row[row][0],
           node->sched->row[row][0], gcd);
     node->sched = isl_mat_scale_down_row(node->sched, row, gcd);
     if (!node->sched)
       goto error;
   }
 
-  if (isl_sort(order, graph->n, sizeof(order[0]), &smaller_value, r) < 0)
-    goto error;
-
-  scc = 0;
-  for (i = 0; i < graph->n; ++i) {
-    if (i > 0 && isl_int_ne(r->el[order[i - 1]], r->el[order[i]]))
-      ++scc;
-    graph->node[order[i]].scc = scc;
-  }
-  graph->scc = ++scc;
-  graph->weak = 0;
-
   isl_int_clear(gcd);
-  isl_vec_free(r);
-  free(order);
-
-  if (update_edges(ctx, graph) < 0)
-    return isl_schedule_node_free(node);
-  node = insert_current_band(node, graph, 0);
-  next_band(graph);
 
-  node = isl_schedule_node_child(node, 0);
-  node = compute_component_schedule(node, graph, 0);
-  node = isl_schedule_node_parent(node);
-
-  return node;
+  return compute_next_band(node, graph, 0);
 error:
-  isl_vec_free(r);
-  free(order);
   isl_int_clear(gcd);
   return isl_schedule_node_free(node);
 }
 
 /* Is the schedule row "sol" trivial on node "node"?
  * That is, is the solution zero on the dimensions linearly independent of
  * the previously found solutions?
  * Return 1 if the solution is trivial, 0 if it is not and -1 on error.
  *
  * Each coefficient is represented as the difference between
- * two non-negative values in "sol".  "sol" has been computed
- * in terms of the original iterators (i.e., without use of cmap).
- * We construct the schedule row s and write it as a linear
- * combination of (linear combinations of) previously computed schedule rows.
- * s = Q c or c = U s.
- * If the final entries of c are all zero, then the solution is trivial.
+ * two non-negative values in "sol".
+ * We construct the schedule row s and check if it is linearly
+ * independent of previously computed schedule rows
+ * by computing T s, with T the linear combinations that are zero
+ * on linearly dependent schedule rows.
+ * If the result consists of all zeros, then the solution is trivial.
  */
 static int is_trivial(struct isl_sched_node *node, __isl_keep isl_vec *sol)
 {
   int trivial;
   isl_vec *node_sol;
 
   if (!sol)
     return -1;
   if (node->nvar == node->rank)
     return 0;
 
   node_sol = extract_var_coef(node, sol);
-  node_sol = isl_mat_vec_product(isl_mat_copy(node->cinv), node_sol);
+  node_sol = isl_mat_vec_product(isl_mat_copy(node->indep), node_sol);
   if (!node_sol)
     return -1;
 
-  trivial = isl_seq_first_non_zero(node_sol->el + node->rank,
+  trivial = isl_seq_first_non_zero(node_sol->el,
           node->nvar - node->rank) == -1;
 
   isl_vec_free(node_sol);
 
   return trivial;
 }
 
 /* Is the schedule row "sol" trivial on any node where it should
  * not be trivial?
- * "sol" has been computed in terms of the original iterators
- * (i.e., without use of cmap).
  * Return 1 if any solution is trivial, 0 if they are not and -1 on error.
  */
 static int is_any_trivial(struct isl_sched_graph *graph,
   __isl_keep isl_vec *sol)
 {
   int i;
 
   for (i = 0; i < graph->n; ++i) {
static int is_any_trivial(struct isl_sched_graph *graph,
   return 0;
 }
 
 /* Does the schedule represented by "sol" perform loop coalescing on "node"?
  * If so, return the position of the coalesced dimension.
  * Otherwise, return node->nvar or -1 on error.
  *
  * In particular, look for pairs of coefficients c_i and c_j such that
- * |c_j/c_i| >= size_i, i.e., |c_j| >= |c_i * size_i|.
+ * |c_j/c_i| > ceil(size_i/2), i.e., |c_j| > |c_i * ceil(size_i/2)|.
  * If any such pair is found, then return i.
  * If size_i is infinity, then no check on c_i needs to be performed.
  */
 static int find_node_coalescing(struct isl_sched_node *node,
   __isl_keep isl_vec *sol)
 {
   int i, j;
   isl_int max;
if (isl_int_is_zero(csol->el[i]))
       continue;
     v = isl_multi_val_get_val(node->sizes, i);
     if (!v)
       goto error;
     if (!isl_val_is_int(v)) {
       isl_val_free(v);
       continue;
     }
+    v = isl_val_div_ui(v, 2);
+    v = isl_val_ceil(v);
+    if (!v)
+      goto error;
     isl_int_mul(max, v->n, csol->el[i]);
     isl_val_free(v);
 
     for (j = 0; j < node->nvar; ++j) {
       if (j == i)
         continue;
-      if (isl_int_abs_ge(csol->el[j], max))
+      if (isl_int_abs_gt(csol->el[j], max))
         break;
     }
     if (j < node->nvar)
       break;
   }
 
   isl_int_clear(max);
   isl_vec_free(csol);
static __isl_give isl_tab_lexmin *zero_out_node_coef(
   dim = isl_tab_lexmin_dim(tl);
   if (dim < 0)
     return isl_tab_lexmin_free(tl);
   eq = isl_vec_alloc(ctx, 1 + dim);
   eq = isl_vec_clr(eq);
   if (!eq)
     return isl_tab_lexmin_free(tl);
 
-  pos = 1 + node_var_coef_offset(node) + 2 * pos;
+  pos = 1 + node_var_coef_pos(node, pos);
   isl_int_set_si(eq->el[pos], 1);
   isl_int_set_si(eq->el[pos + 1], -1);
   tl = isl_tab_lexmin_add_eq(tl, eq->el);
   isl_vec_free(eq);
 
   return tl;
 }
 
map = isl_map_preimage_domain_multi_aff(map,
             isl_multi_aff_copy(edge->src->decompress));
   if (edge->dst->compressed)
     map = isl_map_preimage_range_multi_aff(map,
             isl_multi_aff_copy(edge->dst->decompress));
   umap = isl_union_map_add_map(umap, map);
   return umap;
 }
 
+/* Internal data structure used by union_drop_coalescing_constraints
+ * to collect bounds on all relevant statements.
+ *
+ * "graph" is the schedule constraint graph for which an LP problem
+ * is being constructed.
+ * "bounds" collects the bounds.
+ */
+struct isl_collect_bounds_data {
+  isl_ctx *ctx;
+  struct isl_sched_graph *graph;
+  isl_union_set *bounds;
+};
+
+/* Add the size bounds for the node with instance deltas in "set"
+ * to data->bounds.
+ */
+static isl_stat collect_bounds(__isl_take isl_set *set, void *user)
+{
+  struct isl_collect_bounds_data *data = user;
+  struct isl_sched_node *node;
+  isl_space *space;
+  isl_set *bounds;
+
+  space = isl_set_get_space(set);
+  isl_set_free(set);
+
+  node = graph_find_compressed_node(data->ctx, data->graph, space);
+  isl_space_free(space);
+
+  bounds = isl_set_from_basic_set(get_size_bounds(node));
+  data->bounds = isl_union_set_add_set(data->bounds, bounds);
+
+  return isl_stat_ok;
+}
+
+/* Drop some constraints from "delta" that could be exploited
+ * to construct loop coalescing schedules.
+ * In particular, drop those constraint that bound the difference
+ * to the size of the domain.
+ * Do this for each set/node in "delta" separately.
+ * The parameters are assumed to have been projected out by the caller.
+ */
+static __isl_give isl_union_set *union_drop_coalescing_constraints(isl_ctx *ctx,
+  struct isl_sched_graph *graph, __isl_take isl_union_set *delta)
+{
+  struct isl_collect_bounds_data data = { ctx, graph };
+
+  data.bounds = isl_union_set_empty(isl_space_params_alloc(ctx, 0));
+  if (isl_union_set_foreach_set(delta, &collect_bounds, &data) < 0)
+    data.bounds = isl_union_set_free(data.bounds);
+  delta = isl_union_set_plain_gist(delta, data.bounds);
+
+  return delta;
+}
+
+/* Given a non-trivial lineality space "lineality", add the corresponding
+ * universe set to data->mask and add a map from elements to
+ * other elements along the lines in "lineality" to data->equivalent.
+ * If this is the first time this function gets called
+ * (data->any_non_trivial is still false), then set data->any_non_trivial and
+ * initialize data->mask and data->equivalent.
+ *
+ * In particular, if the lineality space is defined by equality constraints
+ *
+ *  E x = 0
+ *
+ * then construct an affine mapping
+ *
+ *  f : x -> E x
+ *
+ * and compute the equivalence relation of having the same image under f:
+ *
+ *  { x -> x' : E x = E x' }
+ */
+static isl_stat add_non_trivial_lineality(__isl_take isl_basic_set *lineality,
+  struct isl_exploit_lineality_data *data)
+{
+  isl_mat *eq;
+  isl_space *space;
+  isl_set *univ;
+  isl_multi_aff *ma;
+  isl_multi_pw_aff *mpa;
+  isl_map *map;
+  int n;
+
+  if (!lineality)
+    return isl_stat_error;
+  if (isl_basic_set_dim(lineality, isl_dim_div) != 0)
+    isl_die(isl_basic_set_get_ctx(lineality), isl_error_internal,
+      "local variables not allowed", goto error);
+
+  space = isl_basic_set_get_space(lineality);
+  if (!data->any_non_trivial) {
+    data->equivalent = isl_union_map_empty(isl_space_copy(space));
+    data->mask = isl_union_set_empty(isl_space_copy(space));
+  }
+  data->any_non_trivial = isl_bool_true;
+
+  univ = isl_set_universe(isl_space_copy(space));
+  data->mask = isl_union_set_add_set(data->mask, univ);
+
+  eq = isl_basic_set_extract_equalities(lineality);
+  n = isl_mat_rows(eq);
+  eq = isl_mat_insert_zero_rows(eq, 0, 1);
+  eq = isl_mat_set_element_si(eq, 0, 0, 1);
+  space = isl_space_from_domain(space);
+  space = isl_space_add_dims(space, isl_dim_out, n);
+  ma = isl_multi_aff_from_aff_mat(space, eq);
+  mpa = isl_multi_pw_aff_from_multi_aff(ma);
+  map = isl_multi_pw_aff_eq_map(mpa, isl_multi_pw_aff_copy(mpa));
+  data->equivalent = isl_union_map_add_map(data->equivalent, map);
+
+  isl_basic_set_free(lineality);
+  return isl_stat_ok;
+error:
+  isl_basic_set_free(lineality);
+  return isl_stat_error;
+}
+
+/* Check if the lineality space "set" is non-trivial (i.e., is not just
+ * the origin or, in other words, satisfies a number of equality constraints
+ * that is smaller than the dimension of the set).
+ * If so, extend data->mask and data->equivalent accordingly.
+ *
+ * The input should not have any local variables already, but
+ * isl_set_remove_divs is called to make sure it does not.
+ */
+static isl_stat add_lineality(__isl_take isl_set *set, void *user)
+{
+  struct isl_exploit_lineality_data *data = user;
+  isl_basic_set *hull;
+  int dim, 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 (!hull)
+    return isl_stat_error;
+  if (dim != n_eq)
+    return add_non_trivial_lineality(hull, data);
+  isl_basic_set_free(hull);
+  return isl_stat_ok;
+}
+
+/* Check if the difference set on intra-node schedule constraints "intra"
+ * has any non-trivial lineality space.
+ * If so, then extend the difference set to a difference set
+ * on equivalent elements.  That is, if "intra" is
+ *
+ *  { y - x : (x,y) \in V }
+ *
+ * and elements are equivalent if they have the same image under f,
+ * then return
+ *
+ *  { y' - x' : (x,y) \in V and f(x) = f(x') and f(y) = f(y') }
+ *
+ * or, since f is linear,
+ *
+ *  { y' - x' : (x,y) \in V and f(y - x) = f(y' - x') }
+ *
+ * The results of the search for non-trivial lineality spaces is stored
+ * in "data".
+ */
+static __isl_give isl_union_set *exploit_intra_lineality(
+  __isl_take isl_union_set *intra,
+  struct isl_exploit_lineality_data *data)
+{
+  isl_union_set *lineality;
+  isl_union_set *uset;
+
+  data->any_non_trivial = isl_bool_false;
+  lineality = isl_union_set_copy(intra);
+  lineality = isl_union_set_combined_lineality_space(lineality);
+  if (isl_union_set_foreach_set(lineality, &add_lineality, data) < 0)
+    data->any_non_trivial = isl_bool_error;
+  isl_union_set_free(lineality);
+
+  if (data->any_non_trivial < 0)
+    return isl_union_set_free(intra);
+  if (!data->any_non_trivial)
+    return intra;
+
+  uset = isl_union_set_copy(intra);
+  intra = isl_union_set_subtract(intra, isl_union_set_copy(data->mask));
+  uset = isl_union_set_apply(uset, isl_union_map_copy(data->equivalent));
+  intra = isl_union_set_union(intra, uset);
+
+  intra = isl_union_set_remove_divs(intra);
+
+  return intra;
+}
+
+/* If the difference set on intra-node schedule constraints was found to have
+ * any non-trivial lineality space by exploit_intra_lineality,
+ * as recorded in "data", then extend the inter-node
+ * schedule constraints "inter" to schedule constraints on equivalent elements.
+ * That is, if "inter" is V and
+ * elements are equivalent if they have the same image under f, then return
+ *
+ *  { (x', y') : (x,y) \in V and f(x) = f(x') and f(y) = f(y') }
+ */
+static __isl_give isl_union_map *exploit_inter_lineality(
+  __isl_take isl_union_map *inter,
+  struct isl_exploit_lineality_data *data)
+{
+  isl_union_map *umap;
+
+  if (data->any_non_trivial < 0)
+    return isl_union_map_free(inter);
+  if (!data->any_non_trivial)
+    return inter;
+
+  umap = isl_union_map_copy(inter);
+  inter = isl_union_map_subtract_range(inter,
+        isl_union_set_copy(data->mask));
+  umap = isl_union_map_apply_range(umap,
+        isl_union_map_copy(data->equivalent));
+  inter = isl_union_map_union(inter, umap);
+  umap = isl_union_map_copy(inter);
+  inter = isl_union_map_subtract_domain(inter,
+        isl_union_set_copy(data->mask));
+  umap = isl_union_map_apply_range(isl_union_map_copy(data->equivalent),
+        umap);
+  inter = isl_union_map_union(inter, umap);
+
+  inter = isl_union_map_remove_divs(inter);
+
+  return inter;
+}
+
 /* For each (conditional) validity edge in "graph",
  * add the corresponding dependence relation using "add"
  * to a collection of dependence relations and return the result.
  * If "coincidence" is set, then coincidence edges are considered as well.
  */
 static __isl_give isl_union_map *collect_validity(struct isl_sched_graph *graph,
   __isl_give isl_union_map *(*add)(__isl_take isl_union_map *umap,
     struct isl_sched_edge *edge), int coincidence)
if (!is_any_validity(edge) &&
       continue;
 
     umap = add(umap, edge);
   }
 
   return umap;
 }
 
+/* Project out all parameters from "uset" and return the result.
+ */
+static __isl_give isl_union_set *union_set_drop_parameters(
+  __isl_take isl_union_set *uset)
+{
+  unsigned nparam;
+
+  nparam = isl_union_set_dim(uset, isl_dim_param);
+  return isl_union_set_project_out(uset, isl_dim_param, 0, nparam);
+}
+
 /* For each dependence relation on a (conditional) validity edge
  * from a node to itself,
  * construct the set of coefficients of valid constraints for elements
  * in that dependence relation and collect the results.
  * If "coincidence" is set, then coincidence edges are considered as well.
  *
  * In particular, for each dependence relation R, constraints
- * on coefficients (c_0, c_n, c_x) are constructed such that
+ * on coefficients (c_0, c_x) are constructed such that
  *
- *  c_0 + c_n n + c_x d >= 0 for each d in delta R = { y - x | (x,y) in R }
+ *  c_0 + c_x d >= 0 for each d in delta R = { y - x | (x,y) in R }
  *
- * This computation is essentially the same as that performed
+ * If the schedule_treat_coalescing option is set, then some constraints
+ * that could be exploited to construct coalescing schedules
+ * are removed before the dual is computed, but after the parameters
+ * have been projected out.
+ * The entire computation is essentially the same as that performed
  * by intra_coefficients, except that it operates on multiple
- * edges together.
+ * edges together and that the parameters are always projected out.
+ *
+ * Additionally, exploit any non-trivial lineality space
+ * in the difference set after removing coalescing constraints and
+ * store the results of the non-trivial lineality space detection in "data".
+ * The procedure is currently run unconditionally, but it is unlikely
+ * to find any non-trivial lineality spaces if no coalescing constraints
+ * have been removed.
  *
  * Note that if a dependence relation is a union of basic maps,
  * then each basic map needs to be treated individually as it may only
  * be possible to carry the dependences expressed by some of those
  * basic maps and not all of them.
  * The collected validity constraints are therefore not coalesced and
  * it is assumed that they are not coalesced automatically.
  * Duplicate basic maps can be removed, however.
  * In particular, if the same basic map appears as a disjunct
  * in multiple edges, then it only needs to be carried once.
  */
-static __isl_give isl_basic_set_list *collect_intra_validity(
-  struct isl_sched_graph *graph, int coincidence)
+static __isl_give isl_basic_set_list *collect_intra_validity(isl_ctx *ctx,
+  struct isl_sched_graph *graph, int coincidence,
+  struct isl_exploit_lineality_data *data)
 {
   isl_union_map *intra;
   isl_union_set *delta;
   isl_basic_set_list *list;
 
   intra = collect_validity(graph, &add_intra, coincidence);
   delta = isl_union_map_deltas(intra);
+  delta = union_set_drop_parameters(delta);
   delta = isl_union_set_remove_divs(delta);
+  if (isl_options_get_schedule_treat_coalescing(ctx))
+    delta = union_drop_coalescing_constraints(ctx, graph, delta);
+  delta = exploit_intra_lineality(delta, data);
   list = isl_union_set_get_basic_set_list(delta);
   isl_union_set_free(delta);
 
   return isl_basic_set_list_coefficients(list);
 }
 
 /* For each dependence relation on a (conditional) validity edge
  * from a node to some other node,
  * construct the set of coefficients of valid constraints for elements
  * in that dependence relation and collect the results.
  * If "coincidence" is set, then coincidence edges are considered as well.
  *
  * In particular, for each dependence relation R, constraints
  * on coefficients (c_0, c_n, c_x, c_y) are constructed such that
  *
  *  c_0 + c_n n + c_x x + c_y y >= 0 for each (x,y) in R
  *
  * This computation is essentially the same as that performed
  * by inter_coefficients, except that it operates on multiple
  * edges together.
  *
+ * Additionally, exploit any non-trivial lineality space
+ * that may have been discovered by collect_intra_validity
+ * (as stored in "data").
+ *
  * Note that if a dependence relation is a union of basic maps,
  * then each basic map needs to be treated individually as it may only
  * be possible to carry the dependences expressed by some of those
  * basic maps and not all of them.
  * The collected validity constraints are therefore not coalesced and
  * it is assumed that they are not coalesced automatically.
  * Duplicate basic maps can be removed, however.
  * In particular, if the same basic map appears as a disjunct
  * in multiple edges, then it only needs to be carried once.
  */
 static __isl_give isl_basic_set_list *collect_inter_validity(
-  struct isl_sched_graph *graph, int coincidence)
+  struct isl_sched_graph *graph, int coincidence,
+  struct isl_exploit_lineality_data *data)
 {
   isl_union_map *inter;
   isl_union_set *wrap;
   isl_basic_set_list *list;
 
   inter = collect_validity(graph, &add_inter, coincidence);
+  inter = exploit_inter_lineality(inter, data);
   inter = isl_union_map_remove_divs(inter);
   wrap = isl_union_map_wrap(inter);
   list = isl_union_set_get_basic_set_list(wrap);
   isl_union_set_free(wrap);
   return isl_basic_set_list_coefficients(list);
 }
 
 /* Construct an LP problem for finding schedule coefficients
+ * such that the schedule carries as many of the "n_edge" groups of
+ * dependences as possible based on the corresponding coefficient
+ * constraints and return the lexicographically smallest non-trivial solution.
+ * "intra" is the sequence of coefficient constraints for intra-node edges.
+ * "inter" is the sequence of coefficient constraints for inter-node edges.
+ * If "want_integral" is set, then compute an integral solution
+ * for the coefficients rather than using the numerators
+ * of a rational solution.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.
+ *
+ * If none of the "n_edge" groups can be carried
+ * then return an empty vector.
+ */
+static __isl_give isl_vec *compute_carrying_sol_coef(isl_ctx *ctx,
+  struct isl_sched_graph *graph, int n_edge,
+  __isl_keep isl_basic_set_list *intra,
+  __isl_keep isl_basic_set_list *inter, int want_integral,
+  int carry_inter)
+{
+  isl_basic_set *lp;
+
+  if (setup_carry_lp(ctx, graph, n_edge, intra, inter, carry_inter) < 0)
+    return NULL;
+
+  lp = isl_basic_set_copy(graph->lp);
+  return non_neg_lexmin(graph, lp, n_edge, want_integral);
+}
+
+/* Construct an LP problem for finding schedule coefficients
  * such that the schedule carries as many of the validity dependences
  * as possible and
  * return the lexicographically smallest non-trivial solution.
  * If "fallback" is set, then the carrying is performed as a fallback
  * for the Pluto-like scheduler.
  * If "coincidence" is set, then try and carry coincidence edges as well.
  *
  * The variable "n_edge" stores the number of groups that should be carried.
  * If none of the "n_edge" groups can be carried
  * then return an empty vector.
  * If, moreover, "n_edge" is zero, then the LP problem does not even
  * need to be constructed.
  *
  * If a fallback solution is being computed, then compute an integral solution
  * for the coefficients rather than using the numerators
  * of a rational solution.
+ *
+ * If a fallback solution is being computed, if there are any intra-node
+ * dependences, and if requested by the user, then first try
+ * to only carry those intra-node dependences.
+ * If this fails to carry any dependences, then try again
+ * with the inter-node dependences included.
  */
 static __isl_give isl_vec *compute_carrying_sol(isl_ctx *ctx,
   struct isl_sched_graph *graph, int fallback, int coincidence)
 {
   int n_intra, n_inter;
   int n_edge;
-  isl_basic_set *lp;
   struct isl_carry carry = { 0 };
+  isl_vec *sol;
 
-  carry.intra = collect_intra_validity(graph, coincidence);
-  carry.inter = collect_inter_validity(graph, coincidence);
+  carry.intra = collect_intra_validity(ctx, graph, coincidence,
+            &carry.lineality);
+  carry.inter = collect_inter_validity(graph, coincidence,
+            &carry.lineality);
   if (!carry.intra || !carry.inter)
     goto error;
   n_intra = isl_basic_set_list_n_basic_set(carry.intra);
   n_inter = isl_basic_set_list_n_basic_set(carry.inter);
+
+  if (fallback && n_intra > 0 &&
+      isl_options_get_schedule_carry_self_first(ctx)) {
+    sol = compute_carrying_sol_coef(ctx, graph, n_intra,
+        carry.intra, carry.inter, fallback, 0);
+    if (!sol || sol->size != 0 || n_inter == 0) {
+      isl_carry_clear(&carry);
+      return sol;
+    }
+    isl_vec_free(sol);
+  }
+
   n_edge = n_intra + n_inter;
   if (n_edge == 0) {
     isl_carry_clear(&carry);
     return isl_vec_alloc(ctx, 0);
   }
 
-  if (setup_carry_lp(ctx, graph, n_edge, carry.intra, carry.inter) < 0)
-    goto error;
-
+  sol = compute_carrying_sol_coef(ctx, graph, n_edge,
+        carry.intra, carry.inter, fallback, 1);
   isl_carry_clear(&carry);
-  lp = isl_basic_set_copy(graph->lp);
-  return non_neg_lexmin(graph, lp, n_edge, fallback);
+  return sol;
 error:
   isl_carry_clear(&carry);
   return NULL;
 }
 
 /* Construct a schedule row for each node such that as many validity dependences
  * as possible are carried and then continue with the next band.
  * If "fallback" is set, then the carrying is performed as a fallback
static __isl_give isl_schedule_node *carry(__isl_take isl_schedule_node *node,
   trivial = is_any_trivial(graph, sol);
   if (trivial < 0) {
     sol = isl_vec_free(sol);
   } else if (trivial && graph->scc > 1) {
     isl_vec_free(sol);
     return compute_component_schedule(node, graph, 1);
   }
 
-  if (update_schedule(graph, sol, 0, 0) < 0)
+  if (update_schedule(graph, sol, 0) < 0)
     return isl_schedule_node_free(node);
   if (trivial)
     graph->n_row--;
 
   return split_scaled(node, graph);
 }
 
 /* Construct a schedule row for each node such that as many validity dependences

  * The caller keeps looking for a new row as long as
  * graph->n_row < graph->maxvar.  If the latest attempt to find
  * such a row failed (i.e., we still have graph->n_row < graph->maxvar),
  * then we either
  * - split between SCCs and start over (assuming we found an interesting
  *  pair of SCCs between which to split)
  * - continue with the next band (assuming the current band has at least
  *  one row)
+ * - if there is more than one SCC left, then split along all SCCs
  * - if outer coincidence needs to be enforced, then try to carry as many
  *  validity or coincidence dependences as possible and
  *  continue with the next band
  * - try to carry as many validity dependences as possible and
  *  continue with the next band
  * In each case, we first insert a band node in the schedule tree
  * if any rows have been computed.
  *
if (graph->n_row < graph->maxvar) {
 
     ctx = isl_schedule_node_get_ctx(node);
     if (!ctx->opt->schedule_maximize_band_depth && !empty)
       return compute_next_band(node, graph, 1);
     if (graph->src_scc >= 0)
       return compute_split_schedule(node, graph);
     if (!empty)
       return compute_next_band(node, graph, 1);
+    if (graph->scc > 1)
+      return compute_component_schedule(node, graph, 1);
     if (!initialized && compute_maxvar(graph) < 0)
       return isl_schedule_node_free(node);
     if (isl_options_get_schedule_outer_coincidence(ctx))
       return carry_coincidence(node, graph);
     return carry_dependences(node, graph);
   }
 
   insert = graph->n_total_row > graph->band_start;
while (graph->n_row < graph->maxvar) {
     int violated;
     int coincident;
 
     graph->src_scc = -1;
     graph->dst_scc = -1;
 
     if (setup_lp(ctx, graph, use_coincidence) < 0)
       return isl_stat_error;
-    sol = solve_lp(graph);
+    sol = solve_lp(ctx, graph);
     if (!sol)
       return isl_stat_error;
     if (sol->size == 0) {
       int empty = graph->n_total_row == graph->band_start;
 
       isl_vec_free(sol);
       if (use_coincidence && (!force_coincidence || !empty)) {
         use_coincidence = 0;
         continue;
       }
       return isl_stat_ok;
     }
     coincident = !has_coincidence || use_coincidence;
-    if (update_schedule(graph, sol, 1, coincident) < 0)
+    if (update_schedule(graph, sol, coincident) < 0)
       return isl_stat_error;
 
     if (!check_conditional)
       continue;
     violated = has_violated_conditional_constraint(ctx, graph);
     if (violated < 0)
       return isl_stat_error;
     if (!violated)
for (i = 0; i < c->n; ++i) {
     scc = &c->scc[i];
     nvar = scc->n_total_row - scc->band_start;
     if (nvar != maxvar)
       continue;
     for (j = 0; j < scc->n; ++j) {
       struct isl_sched_node *node = &scc->node[j];
       int slack;
 
-      if (node_update_cmap(node) < 0)
+      if (node_update_vmap(node) < 0)
         return -1;
       slack = node->nvar - node->rank;
       if (slack > max_slack)
         max_slack = slack;
     }
   }
 
   return max_slack;
for (i = 0; i < c->n; ++i) {
     scc = &c->scc[i];
     nvar = scc->n_total_row - scc->band_start;
     if (nvar >= maxvar)
       continue;
     for (j = 0; j < scc->n; ++j) {
       struct isl_sched_node *node = &scc->node[j];
       int slack;
 
-      if (node_update_cmap(node) < 0)
+      if (node_update_vmap(node) < 0)
         return -1;
       slack = node->nvar - node->rank;
       if (slack > max_slack) {
         maxvar = nvar;
         break;
       }
     }
   }
if (bad_cluster(&c->scc[edge->src->scc]) ||
         bad_cluster(&c->scc[edge->dst->scc]))
       continue;
     if (c->scc_cluster[edge->dst->scc] ==
         c->scc_cluster[edge->src->scc])
       continue;
 
     hull = isl_map_affine_hull(isl_map_copy(edge->map));
     hull = isl_basic_map_transform_dims(hull, isl_dim_in, 0,
-                isl_mat_copy(src->ctrans));
+                isl_mat_copy(src->vmap));
     hull = isl_basic_map_transform_dims(hull, isl_dim_out, 0,
-                isl_mat_copy(dst->ctrans));
+                isl_mat_copy(dst->vmap));
     hull = isl_basic_map_project_out(hull,
             isl_dim_in, 0, src->rank);
     hull = isl_basic_map_project_out(hull,
             isl_dim_out, 0, dst->rank);
     hull = isl_basic_map_remove_divs(hull);
     n_in = isl_basic_map_dim(hull, isl_dim_in);
     n_out = isl_basic_map_dim(hull, isl_dim_out);
     hull = isl_basic_map_drop_constraints_not_involving_dims(hull,

polly/trunk/lib/External/isl/isl_tab.h

 #define ISL_OPT_QE    (1 << 2)
 __isl_give isl_map *isl_tab_basic_map_partial_lexopt(
   __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
   __isl_give isl_set **empty, unsigned flags);
 __isl_give isl_pw_multi_aff *isl_tab_basic_map_partial_lexopt_pw_multi_aff(
   __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
   __isl_give isl_set **empty, unsigned flags);
 
-/* An isl_region represents a sequence of consecutive variables.
+/* An isl_trivial_region represents a non-triviality region.
+ * The region is trivial if applying "trivial" to a given sequence
+ * of variables results in a zero vector.
  * pos is the location (starting at 0) of the first variable in the sequence.
  */
-struct isl_region {
+struct isl_trivial_region {
   int pos;
-  int len;
+  isl_mat *trivial;
 };
 
 __isl_give isl_vec *isl_tab_basic_set_non_trivial_lexmin(
   __isl_take isl_basic_set *bset, int n_op, int n_region,
-  struct isl_region *region,
+  struct isl_trivial_region *region,
   int (*conflict)(int con, void *user), void *user);
 
 struct isl_tab_lexmin;
 typedef struct isl_tab_lexmin isl_tab_lexmin;
 
 __isl_give isl_tab_lexmin *isl_tab_lexmin_from_basic_set(
   __isl_take isl_basic_set *bset);
 int isl_tab_lexmin_dim(__isl_keep isl_tab_lexmin *tl);

polly/trunk/lib/External/isl/isl_tab_pip.c

 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
- * Copyright 2016      Sven Verdoolaege
+ * Copyright 2016-2017 Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege, K.U.Leuven, Departement
  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
  */
isl_stat isl_basic_map_foreach_lexopt(__isl_keep isl_basic_map *bmap, int max,
   isl_basic_map_free(bmap);
   return isl_stat_ok;
 error:
   sol_free(&sol_for->sol);
   isl_basic_map_free(bmap);
   return isl_stat_error;
 }
 
-/* Check if the given sequence of len variables starting at pos
- * represents a trivial (i.e., zero) solution.
- * The variables are assumed to be non-negative and to come in pairs,
- * with each pair representing a variable of unrestricted sign.
- * The solution is trivial if each such pair in the sequence consists
- * of two identical values, meaning that the variable being represented
- * has value zero.
+/* Extract the subsequence of the sample value of "tab"
+ * starting at "pos" and of length "len".
  */
-static int region_is_trivial(struct isl_tab *tab, int pos, int len)
+static __isl_give isl_vec *extract_sample_sequence(struct isl_tab *tab,
+  int pos, int len)
 {
   int i;
+  isl_ctx *ctx;
+  isl_vec *v;
 
-  if (len == 0)
-    return 0;
+  ctx = isl_tab_get_ctx(tab);
+  v = isl_vec_alloc(ctx, len);
+  if (!v)
+    return NULL;
+  for (i = 0; i < len; ++i) {
+    if (!tab->var[pos + i].is_row) {
+      isl_int_set_si(v->el[i], 0);
+    } else {
+      int row;
 
-  for (i = 0; i < len; i +=  2) {
-    int neg_row;
-    int pos_row;
+      row = tab->var[pos + i].index;
+      isl_int_set(v->el[i], tab->mat->row[row][1]);
+    }
+  }
 
-    neg_row = tab->var[pos + i].is_row ?
-        tab->var[pos + i].index : -1;
-    pos_row = tab->var[pos + i + 1].is_row ?
-        tab->var[pos + i + 1].index : -1;
+  return v;
+}
 
-    if ((neg_row < 0 ||
-         isl_int_is_zero(tab->mat->row[neg_row][1])) &&
-        (pos_row < 0 ||
-         isl_int_is_zero(tab->mat->row[pos_row][1])))
-      continue;
+/* Check if the sequence of variables starting at "pos"
+ * represents a trivial solution according to "trivial".
+ * That is, is the result of applying "trivial" to this sequence
+ * equal to the zero vector?
+ */
+static isl_bool region_is_trivial(struct isl_tab *tab, int pos,
+  __isl_keep isl_mat *trivial)
+{
+  int n, len;
+  isl_vec *v;
+  isl_bool is_trivial;
 
-    if (neg_row < 0 || pos_row < 0)
-      return 0;
-    if (isl_int_ne(tab->mat->row[neg_row][1],
-             tab->mat->row[pos_row][1]))
-      return 0;
-  }
+  if (!trivial)
+    return isl_bool_error;
 
-  return 1;
+  n = isl_mat_rows(trivial);
+  if (n == 0)
+    return isl_bool_false;
+
+  len = isl_mat_cols(trivial);
+  v = extract_sample_sequence(tab, pos, len);
+  v = isl_mat_vec_product(isl_mat_copy(trivial), v);
+  is_trivial = isl_vec_is_zero(v);
+  isl_vec_free(v);
+
+  return is_trivial;
 }
 
-/* Return the index of the first trivial region or -1 if all regions
- * are non-trivial.
+/* Return the index of the first trivial region, "n_region" if all regions
+ * are non-trivial or -1 in case of error.
  */
 static int first_trivial_region(struct isl_tab *tab,
-  int n_region, struct isl_region *region)
+  int n_region, struct isl_trivial_region *region)
 {
   int i;
 
   for (i = 0; i < n_region; ++i) {
-    if (region_is_trivial(tab, region[i].pos, region[i].len))
+    isl_bool trivial;
+    trivial = region_is_trivial(tab, region[i].pos,
+          region[i].trivial);
+    if (trivial < 0)
+      return -1;
+    if (trivial)
       return i;
   }
 
-  return -1;
+  return n_region;
 }
 
 /* Check if the solution is optimal, i.e., whether the first
  * n_op entries are zero.
  */
 static int is_optimal(__isl_keep isl_vec *sol, int n_op)
 {
   int i;
static int force_better_solution(struct isl_tab *tab,
 
   isl_vec_free(v);
   return n;
 error:
   isl_vec_free(v);
   return -1;
 }
 
+/* Global internal data for isl_tab_basic_set_non_trivial_lexmin.
+ *
+ * "v" is a pre-allocated vector that can be used for adding
+ * constraints to the tableau.
+ */
+struct isl_trivial_global {
+  isl_vec *v;
+};
+
+/* Fix triviality direction "dir" of the given region to zero.
+ *
+ * This function assumes that at least two more rows and at least
+ * two more elements in the constraint array are available in the tableau.
+ */
+static isl_stat fix_zero(struct isl_tab *tab, struct isl_trivial_region *region,
+  int dir, struct isl_trivial_global *data)
+{
+  int len;
+
+  data->v = isl_vec_clr(data->v);
+  if (!data->v)
+    return isl_stat_error;
+  len = isl_mat_cols(region->trivial);
+  isl_seq_cpy(data->v->el + 1 + region->pos, region->trivial->row[dir],
+        len);
+  if (add_lexmin_eq(tab, data->v->el) < 0)
+    return isl_stat_error;
+
+  return isl_stat_ok;
+}
+
+/* This function selects case "side" for non-triviality region "region",
+ * assuming all the equality constraints have been imposed already.
+ * In particular, the triviality direction side/2 is made positive
+ * if side is even and made negative if side is odd.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
+ */
+static struct isl_tab *pos_neg(struct isl_tab *tab,
+  struct isl_trivial_region *region,
+  int side, struct isl_trivial_global *data)
+{
+  int len;
+
+  data->v = isl_vec_clr(data->v);
+  if (!data->v)
+    goto error;
+  isl_int_set_si(data->v->el[0], -1);
+  len = isl_mat_cols(region->trivial);
+  if (side % 2 == 0)
+    isl_seq_cpy(data->v->el + 1 + region->pos,
+          region->trivial->row[side / 2], len);
+  else
+    isl_seq_neg(data->v->el + 1 + region->pos,
+          region->trivial->row[side / 2], len);
+  return add_lexmin_ineq(tab, data->v->el);
+error:
+  isl_tab_free(tab);
+  return NULL;
+}
+
 /* Local data at each level of the backtracking procedure of
  * isl_tab_basic_set_non_trivial_lexmin.
  *
+ * "update" is set if a solution has been found in the current case
+ * of this level, such that a better solution needs to be enforced
+ * in the next case.
  * "n_zero" is the number of initial coordinates that have already
  * been forced to be zero at this level.
+ * "region" is the non-triviality region considered at this level.
+ * "side" is the index of the current case at this level.
+ * "n" is the number of triviality directions.
  */
 struct isl_trivial {
   int update;
   int n_zero;
   int region;
   int side;
+  int n;
   struct isl_tab_undo *snap;
 };
 
 /* Return the lexicographically smallest non-trivial solution of the
  * given ILP problem.
  *
  * All variables are assumed to be non-negative.
  *
  * n_op is the number of initial coordinates to optimize.
  * That is, once a solution has been found, we will only continue looking
  * for solutions that result in significantly better values for those
  * initial coordinates.  That is, we only continue looking for solutions
  * that increase the number of initial zeros in this sequence.
  *
  * A solution is non-trivial, if it is non-trivial on each of the
- * specified regions.  Each region represents a sequence of pairs
- * of variables.  A solution is non-trivial on such a region if
- * at least one of these pairs consists of different values, i.e.,
- * such that the non-negative variable represented by the pair is non-zero.
+ * specified regions.  Each region represents a sequence of
+ * triviality directions on a sequence of variables that starts
+ * at a given position.  A solution is non-trivial on such a region if
+ * at least one of the triviality directions is non-zero
+ * on that sequence of variables.
  *
  * Whenever a conflict is encountered, all constraints involved are
  * reported to the caller through a call to "conflict".
  *
  * We perform a simple branch-and-bound backtracking search.
  * Each level in the search represents an initially trivial region
  * that is forced to be non-trivial.
- * At each level we consider n cases, where n is the length of the region.
- * In terms of the n/2 variables of unrestricted signs being encoded by
- * the region, we consider the cases
- *  x_0 >= 1
- *  x_0 <= -1
- *  x_0 = 0 and x_1 >= 1
- *  x_0 = 0 and x_1 <= -1
- *  x_0 = 0 and x_1 = 0 and x_2 >= 1
- *  x_0 = 0 and x_1 = 0 and x_2 <= -1
+ * At each level we consider 2 * n cases, where n
+ * is the number of triviality directions.
+ * In terms of those n directions v_i, we consider the cases
+ *  v_0 >= 1
+ *  v_0 <= -1
+ *  v_0 = 0 and v_1 >= 1
+ *  v_0 = 0 and v_1 <= -1
+ *  v_0 = 0 and v_1 = 0 and v_2 >= 1
+ *  v_0 = 0 and v_1 = 0 and v_2 <= -1
  *  ...
- * The cases are considered in this order, assuming that each pair
- * x_i_a x_i_b represents the value x_i_b - x_i_a.
- * That is, x_0 >= 1 is enforced by adding the constraint
- *  x_0_b - x_0_a >= 1
+ * in this order.
  */
 __isl_give isl_vec *isl_tab_basic_set_non_trivial_lexmin(
   __isl_take isl_basic_set *bset, int n_op, int n_region,
-  struct isl_region *region,
+  struct isl_trivial_region *region,
   int (*conflict)(int con, void *user), void *user)
 {
-  int i, j;
+  struct isl_trivial_global data = { 0 };
+  int i;
   int r;
   isl_ctx *ctx;
-  isl_vec *v = NULL;
   isl_vec *sol = NULL;
   struct isl_tab *tab;
   struct isl_trivial *triv = NULL;
   int level, init;
 
   if (!bset)
     return NULL;
 
   ctx = isl_basic_set_get_ctx(bset);
   sol = isl_vec_alloc(ctx, 0);
 
   tab = tab_for_lexmin(bset, NULL, 0, 0);
   if (!tab)
     goto error;
   tab->conflict = conflict;
   tab->conflict_user = user;
 
-  v = isl_vec_alloc(ctx, 1 + tab->n_var);
+  data.v = isl_vec_alloc(ctx, 1 + tab->n_var);
   triv = isl_calloc_array(ctx, struct isl_trivial, n_region);
-  if (!v || (n_region && !triv))
+  if (!data.v || (n_region && !triv))
     goto error;
 
   level = 0;
   init = 1;
 
   while (level >= 0) {
     int side, base;
 
     if (init) {
       tab = cut_to_integer_lexmin(tab, CUT_ONE);
       if (!tab)
         goto error;
       if (tab->empty)
         goto backtrack;
       r = first_trivial_region(tab, n_region, region);
-      if (r < 0) {
+      if (r < 0)
+        goto error;
+      if (r == n_region) {
         for (i = 0; i < level; ++i)
           triv[i].update = 1;
         isl_vec_free(sol);
         sol = isl_tab_get_sample_value(tab);
         if (!sol)
           goto error;
         if (is_optimal(sol, n_op))
           break;
         goto backtrack;
       }
       if (level >= n_region)
         isl_die(ctx, isl_error_internal,
           "nesting level too deep", goto error);
+      triv[level].n = isl_mat_rows(region[r].trivial);
       if (isl_tab_extend_cons(tab,
-              2 * region[r].len + 2 * n_op) < 0)
+              2 * triv[level].n + 2 * n_op) < 0)
         goto error;
       triv[level].region = r;
       triv[level].side = 0;
       triv[level].update = 0;
       triv[level].n_zero = 0;
     }
 
     r = triv[level].region;
     side = triv[level].side;
     base = 2 * (side/2);
 
-    if (side >= region[r].len) {
+    if (side >= 2 * triv[level].n) {
 backtrack:
       level--;
       init = 0;
       if (level >= 0)
         if (isl_tab_rollback(tab, triv[level].snap) < 0)
           goto error;
       continue;
     }
 
     if (triv[level].update) {
       triv[level].n_zero = force_better_solution(tab, sol,
                 n_op, triv[level].n_zero);
       if (triv[level].n_zero < 0)
         goto error;
       triv[level].update = 0;
     }
 
-    if (side == base && base >= 2) {
-      for (j = base - 2; j < base; ++j) {
-        v = isl_vec_clr(v);
-        isl_int_set_si(v->el[1 + region[r].pos + j], 1);
-        if (add_lexmin_eq(tab, v->el) < 0)
-          goto error;
-      }
-    }
+    if (side == base && base >= 2 &&
+        fix_zero(tab, &region[r], base / 2 - 1, &data) < 0)
 
     triv[level].snap = isl_tab_snap(tab);
     if (isl_tab_push_basis(tab) < 0)
       goto error;
 
-    v = isl_vec_clr(v);
-    isl_int_set_si(v->el[0], -1);
-    isl_int_set_si(v->el[1 + region[r].pos + side], -1);
-    isl_int_set_si(v->el[1 + region[r].pos + (side ^ 1)], 1);
-    tab = add_lexmin_ineq(tab, v->el);
+    tab = pos_neg(tab, &region[r], side, &data);
+    if (!tab)
+      goto error;
 
     triv[level].side++;
     level++;
     init = 1;
   }
 
   free(triv);
-  isl_vec_free(v);
+  isl_vec_free(data.v);
   isl_tab_free(tab);
   isl_basic_set_free(bset);
 
   return sol;
 error:
   free(triv);
-  isl_vec_free(v);
+  isl_vec_free(data.v);
   isl_tab_free(tab);
   isl_basic_set_free(bset);
   isl_vec_free(sol);
   return NULL;
 }
 
 /* Wrapper for a tableau that is used for computing
  * the lexicographically smallest rational point of a non-negative set.

polly/trunk/lib/External/isl/isl_test.c

static int test_bounded(isl_ctx *ctx)
   if (bounded)
     isl_die(ctx, isl_error_unknown,
       "set considered bounded", return -1);
 
   return 0;
 }
 
 /* Construct the basic set { [i] : 5 <= i <= N } */
-static int test_construction(isl_ctx *ctx)
+static int test_construction_1(isl_ctx *ctx)
 {
   isl_int v;
   isl_space *dim;
   isl_local_space *ls;
   isl_basic_set *bset;
   isl_constraint *c;
 
   isl_int_init(v);
static int test_construction_1(isl_ctx *ctx)
   isl_local_space_free(ls);
   isl_basic_set_free(bset);
 
   isl_int_clear(v);
 
   return 0;
 }
 
+/* Construct the basic set { [x] : -100 <= x <= 100 }
+ * using isl_basic_set_{lower,upper}_bound_val and
+ * check that it is equal the same basic set parsed from a string.
+ */
+static int test_construction_2(isl_ctx *ctx)
+{
+  isl_bool equal;
+  isl_val *v;
+  isl_space *space;
+  isl_basic_set *bset1, *bset2;
+
+  v = isl_val_int_from_si(ctx, 100);
+  space = isl_space_set_alloc(ctx, 0, 1);
+  bset1 = isl_basic_set_universe(space);
+  bset1 = isl_basic_set_upper_bound_val(bset1, isl_dim_set, 0,
+            isl_val_copy(v));
+  bset1 = isl_basic_set_lower_bound_val(bset1, isl_dim_set, 0,
+            isl_val_neg(v));
+  bset2 = isl_basic_set_read_from_str(ctx, "{ [x] : -100 <= x <= 100 }");
+  equal = isl_basic_set_is_equal(bset1, bset2);
+  isl_basic_set_free(bset1);
+  isl_basic_set_free(bset2);
+
+  if (equal < 0)
+    return -1;
+  if (!equal)
+    isl_die(ctx, isl_error_unknown,
+      "failed construction", return -1);
+
+  return 0;
+}
+
+/* Basic tests for constructing basic sets.
+ */
+static int test_construction(isl_ctx *ctx)
+{
+  if (test_construction_1(ctx) < 0)
+    return -1;
+  if (test_construction_2(ctx) < 0)
+    return -1;
+  return 0;
+}
+
 static int test_dim(isl_ctx *ctx)
 {
   const char *str;
   isl_map *map1, *map2;
   int equal;
 
   map1 = isl_map_read_from_str(ctx,
       "[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
if (equal < 0)
     return -1;
   if (!equal)
     isl_die(ctx, isl_error_unknown,
       "unexpected schedule", return -1);
 
   return 0;
 }
 
+/* Check that the bounds on the coefficients are respected.
+ * This function checks for a particular output schedule,
+ * but the exact output is not important, only that it does
+ * not contain any coefficients greater than 4.
+ * It is, however, easier to check for a particular output.
+ * This test is only run for the whole component scheduler
+ * because the incremental scheduler produces a slightly different schedule.
+ */
+static int test_bounded_coefficients_schedule_whole(isl_ctx *ctx)
+{
+  const char *domain, *dep, *str;
+  isl_union_set *I;
+  isl_union_map *D;
+  isl_schedule_constraints *sc;
+  isl_schedule *schedule;
+  isl_union_map *sched1, *sched2;
+  isl_bool equal;
+
+  domain = "{ S_4[i, j, k] : 0 <= i < j <= 10 and 0 <= k <= 100; "
+      "S_2[i, j] : 0 <= i < j <= 10; S_6[i, j] : 0 <= i < j <= 10 }";
+  dep = "{ S_2[0, j] -> S_4[0, j, 0] : 0 < j <= 10; "
+      "S_4[0, j, 100] -> S_6[0, j] : 0 < j <= 10 }";
+  I = isl_union_set_read_from_str(ctx, domain);
+  D = isl_union_map_read_from_str(ctx, dep);
+  sc = isl_schedule_constraints_on_domain(I);
+  sc = isl_schedule_constraints_set_validity(sc, D);
+  isl_options_set_schedule_max_constant_term(ctx, 10);
+  isl_options_set_schedule_max_coefficient(ctx, 4);
+  schedule = isl_schedule_constraints_compute_schedule(sc);
+  isl_options_set_schedule_max_coefficient(ctx, -1);
+  isl_options_set_schedule_max_constant_term(ctx, -1);
+  sched1 = isl_schedule_get_map(schedule);
+  isl_schedule_free(schedule);
+
+  str = "{ S_4[i, j, k] -> [i, j, 10 - k, 1]; "
+      "S_2[i, j] -> [0, i, j, 0]; S_6[i, j] -> [0, 10 + i, j, 2] }";
+  sched2 = isl_union_map_read_from_str(ctx, str);
+  equal = isl_union_map_is_equal(sched1, sched2);
+  isl_union_map_free(sched1);
+  isl_union_map_free(sched2);
+
+  if (equal < 0)
+    return -1;
+  if (!equal)
+    isl_die(ctx, isl_error_unknown,
+      "unexpected schedule", return -1);
+
+  return 0;
+}
+
 /* Check that a set of schedule constraints that only allow for
  * a coalescing schedule still produces a schedule even if the user
  * request a non-coalescing schedule.  Earlier versions of isl
  * would not handle this case correctly.
  */
 static int test_coalescing_schedule(isl_ctx *ctx)
 {
   const char *domain, *dep;
static int test_coalescing_schedule(isl_ctx *ctx)
   schedule = isl_schedule_constraints_compute_schedule(sc);
   isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
   isl_schedule_free(schedule);
   if (!schedule)
     return -1;
   return 0;
 }
 
+/* Check that the scheduler does not perform any needless
+ * compound skewing.  Earlier versions of isl would compute
+ * schedules in terms of transformed schedule coefficients and
+ * would not accurately keep track of the sum of the original
+ * schedule coefficients.  It could then produce the schedule
+ * S[t,i,j,k] -> [t, 2t + i, 2t + i + j, 2t + i + j + k]
+ * for the input below instead of the schedule below.
+ */
+static int test_skewing_schedule(isl_ctx *ctx)
+{
+  const char *D, *V, *P, *S;
+
+  D = "[n] -> { S[t,i,j,k] : 0 <= t,i,j,k < n }";
+  V = "[n] -> { S[t,i,j,k] -> S[t+1,a,b,c] : 0 <= t,i,j,k,a,b,c < n and "
+    "-2 <= a-i <= 2 and -1 <= a-i + b-j <= 1 and "
+    "-1 <= a-i + b-j + c-k <= 1 }";
+  P = "{ }";
+  S = "{ S[t,i,j,k] -> [t, 2t + i, t + i + j, 2t + k] }";
+
+  return test_special_schedule(ctx, D, V, P, S);
+}
+
 int test_schedule(isl_ctx *ctx)
 {
   const char *D, *W, *R, *V, *P, *S;
   int max_coincidence;
   int treat_coalescing;
 
   /* Handle resulting schedule with zero bands. */
   if (test_one_schedule(ctx, "{[]}", "{}", "{}", "{[] -> []}", 0, 0) < 0)
V = "{Stmt_for_body24[0, i1, i2, i3] -> "
     "Stmt_for_body24[i0, o1, -1 + i2 - o1, -1 + i1 - o1]:"
     "i0 >= 0 and i0 <= 1 and o1 >= 0 and i2 >= 1 + i1 and "
     "o1 <= -2 + i2 and i2 <= 7 and o1 <= -1 + i1;"
         "Stmt_for_body7[i0, i1, i2] -> "
     "Stmt_for_body24[i0, i1, o2, -1 - i1 + i2]:"
     "i0 >= 0 and i0 <= 1 and i1 >= 0 and o2 >= -i1 + i2 and "
     "o2 >= 1 and o2 <= 6 - i1 and i2 >= 1 + i1 }";
   P = V;
-  S = "{ Stmt_for_body24[i0, i1, i2, i3] -> "
-    "[i0, 5i0 + i1, 6i0 + i1 + i2, 1 + 6i0 + i1 + i2 + i3, 1];"
-      "Stmt_for_body7[i0, i1, i2] -> [0, 5i0, 6i0 + i1, 6i0 + i2, 0] }";
 
   treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
   isl_options_set_schedule_treat_coalescing(ctx, 0);
-  if (test_special_schedule(ctx, D, V, P, S) < 0)
+  if (test_has_schedule(ctx, D, V, P) < 0)
     return -1;
   isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
 
   D = "{ S_0[i, j] : i >= 1 and i <= 10 and j >= 1 and j <= 8 }";
   V = "{ S_0[i, j] -> S_0[i, 1 + j] : i >= 1 and i <= 10 and "
              "j >= 1 and j <= 7;"
     "S_0[i, j] -> S_0[1 + i, j] : i >= 1 and i <= 9 and "
                "j >= 1 and j <= 8 }";
   P = "{ }";
-  S = "{ S_0[i, j] -> [i + j, j] }";
+  S = "{ S_0[i, j] -> [i + j, i] }";
   ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
   if (test_special_schedule(ctx, D, V, P, S) < 0)
     return -1;
   ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
 
   /* Fig. 1 from Feautrier's "Some Efficient Solutions..." pt. 2, 1992 */
   D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and "
          "j >= 0 and j <= -1 + i }";
int test_schedule(isl_ctx *ctx)
 
   if (test_conflicting_context_schedule(ctx) < 0)
     return -1;
 
   if (test_bounded_coefficients_schedule(ctx) < 0)
     return -1;
   if (test_coalescing_schedule(ctx) < 0)
     return -1;
+  if (test_skewing_schedule(ctx) < 0)
+    return -1;
 
   return 0;
 }
 
 /* Perform scheduling tests using the whole component scheduler.
  */
 static int test_schedule_whole(isl_ctx *ctx)
 {
   int whole;
   int r;
 
   whole = isl_options_get_schedule_whole_component(ctx);
   isl_options_set_schedule_whole_component(ctx, 1);
   r = test_schedule(ctx);
+  if (r >= 0)
+    r = test_bounded_coefficients_schedule_whole(ctx);
   isl_options_set_schedule_whole_component(ctx, whole);
 
   return r;
 }
 
 /* Perform scheduling tests using the incremental scheduler.
  */
 static int test_schedule_incremental(isl_ctx *ctx)

polly/trunk/lib/External/isl/isl_test_int.c

static void int_test_divexact(isl_int expected, isl_int lhs, isl_int rhs)
   if (isl_int_fits_ulong(rhs)) {
     rhsulong = isl_int_get_ui(rhs);
 
     isl_int_divexact_ui(result, lhs, rhsulong);
     assert(isl_int_eq(expected, result));
 
     isl_int_fdiv_q_ui(result, lhs, rhsulong);
     assert(isl_int_eq(expected, result));
+
+    isl_int_cdiv_q_ui(result, lhs, rhsulong);
+    assert(isl_int_eq(expected, result));
   }
 
   isl_int_clear(result);
 }
 
 static void int_test_mul(isl_int expected, isl_int lhs, isl_int rhs)
 {
   isl_int result;
if (isl_int_fits_ulong(rhs)) {
     assert(isl_int_eq(expected, result));
   }
 
   isl_int_clear(result);
 }
 
 static void int_test_cdiv(isl_int expected, isl_int lhs, isl_int rhs)
 {
+  unsigned long rhsulong;
   isl_int result;
   isl_int_init(result);
 
   isl_int_cdiv_q(result, lhs, rhs);
   assert(isl_int_eq(expected, result));
 
+  if (isl_int_fits_ulong(rhs)) {
+    rhsulong = isl_int_get_ui(rhs);
+
+    isl_int_cdiv_q_ui(result, lhs, rhsulong);
+    assert(isl_int_eq(expected, result));
+  }
+
   isl_int_clear(result);
 }
 
 static void int_test_tdiv(isl_int expected, isl_int lhs, isl_int rhs)
 {
   isl_int result;
   isl_int_init(result);
 
struct {
   { &int_test_fdiv, "0", "-1", "-2" },
   { &int_test_fdiv_r, "-1", "-1", "-3" },
 
   { &int_test_cdiv, "1", "1", "2" },
   { &int_test_cdiv, "0", "-1", "2" },
   { &int_test_cdiv, "0", "1", "-2" },
   { &int_test_cdiv, "1", "-1", "-2" },
 
+  { &int_test_cdiv, "1073741824", "2147483647", "2" },
+  { &int_test_cdiv, "1073741824", "2147483648", "2" },
+  { &int_test_cdiv, "-1073741824", "-2147483648", "2" },
+  { &int_test_cdiv, "-1073741823", "-2147483647", "2" },
+
   { &int_test_tdiv, "0", "1", "2" },
   { &int_test_tdiv, "0", "-1", "2" },
   { &int_test_tdiv, "0", "1", "-2" },
   { &int_test_tdiv, "0", "-1", "-2" },
 
   { &int_test_gcd, "0", "0", "0" },
   { &int_test_lcm, "0", "0", "0" },
   { &int_test_gcd, "7", "0", "7" },

polly/trunk/lib/External/isl/isl_union_map.c

 #include <isl_union_map_private.h>
 #include <isl/ctx.h>
 #include <isl/hash.h>
 #include <isl/aff.h>
 #include <isl/map.h>
 #include <isl/set.h>
 #include <isl_space_private.h>
 #include <isl/union_set.h>
+#include <isl_maybe_map.h>
 #include <isl/deprecated/union_map_int.h>
 
 #include <bset_from_bmap.c>
 #include <set_to_map.c>
 #include <set_from_map.c>
 
 /* Return the number of parameters of "umap", where "type"
  * is required to be set to isl_dim_param.
isl_bool isl_union_map_space_has_equal_params(__isl_keep isl_union_map *umap,
   __isl_keep isl_space *space)
 {
   isl_space *umap_space;
 
   umap_space = isl_union_map_peek_space(umap);
   return isl_space_has_equal_params(umap_space, space);
 }
 
-static int has_dim(const void *entry, const void *val)
+static int has_space(const void *entry, const void *val)
 {
   isl_map *map = (isl_map *)entry;
-  isl_space *dim = (isl_space *)val;
+  isl_space *space = (isl_space *) val;
 
-  return isl_space_is_equal(map->dim, dim);
+  return isl_space_is_equal(map->dim, space);
 }
 
 __isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap,
   __isl_take isl_map *map)
 {
   uint32_t hash;
   struct isl_hash_table_entry *entry;
   isl_bool aligned;
__isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap,
 
   umap = isl_union_map_cow(umap);
 
   if (!map || !umap)
     goto error;
 
   hash = isl_space_get_hash(map->dim);
   entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-            &has_dim, map->dim, 1);
+            &has_space, map->dim, 1);
   if (!entry)
     goto error;
 
   if (!entry->data)
     entry->data = map;
   else {
     entry->data = isl_map_union(entry->data, isl_map_copy(map));
     if (!entry->data)
__isl_give isl_map *isl_union_map_extract_map(__isl_keep isl_union_map *umap,
   space = isl_space_drop_dims(space, isl_dim_param,
           0, isl_space_dim(space, isl_dim_param));
   space = isl_space_align_params(space, isl_union_map_get_space(umap));
   if (!umap || !space)
     goto error;
 
   hash = isl_space_get_hash(space);
   entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-            &has_dim, space, 0);
+            &has_space, space, 0);
   if (!entry)
     return isl_map_empty(space);
   isl_space_free(space);
   return isl_map_copy(entry->data);
 error:
   isl_space_free(space);
   return NULL;
 }
isl_bool isl_union_map_contains(__isl_keep isl_union_map *umap,
   uint32_t hash;
   struct isl_hash_table_entry *entry;
 
   if (!umap || !space)
     return isl_bool_error;
 
   hash = isl_space_get_hash(space);
   entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-            &has_dim, space, 0);
+            &has_space, space, 0);
   return !!entry;
 }
 
 isl_bool isl_union_set_contains(__isl_keep isl_union_set *uset,
   __isl_keep isl_space *space)
 {
   return isl_union_map_contains(uset, space);
 }

 
 isl_stat isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
   isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user)
 {
   struct isl_union_set_foreach_point_data data = { fn, user };
   return isl_union_set_foreach_set(uset, &foreach_point, &data);
 }
 
+/* Data structure that specifies how gen_bin_op should
+ * construct results from the inputs.
+ *
+ * If "subtract" is set, then a map in the first input is copied to the result
+ * if there is no corresponding map in the second input.
+ * Otherwise, a map in the first input with no corresponding map
+ * in the second input is ignored.
+ * If "filter" is not NULL, then it specifies which maps in the first
+ * input may have a matching map in the second input.
+ * In particular, it makes sure that "match_space" can be called
+ * on the space of the map.
+ * "match_space" specifies how to transform the space of a map
+ * in the first input to the space of the corresponding map
+ * in the second input.
+ * "fn_map" specifies how the matching maps, one from each input,
+ * should be combined to form a map in the result.
+ */
+struct isl_bin_op_control {
+  int subtract;
+  isl_bool (*filter)(__isl_keep isl_map *map);
+  __isl_give isl_space *(*match_space)(__isl_take isl_space *space);
+  __isl_give isl_map *(*fn_map)(__isl_take isl_map *map1,
+    __isl_take isl_map *map2);
+};
+
+/* Internal data structure for gen_bin_op.
+ * "control" specifies how the maps in the result should be constructed.
+ * "umap2" is a pointer to the second argument.
+ * "res" collects the results.
+ */
 struct isl_union_map_gen_bin_data {
+  struct isl_bin_op_control *control;
   isl_union_map *umap2;
   isl_union_map *res;
 };
 
-static isl_stat subtract_entry(void **entry, void *user)
+/* Add a copy of "map" to "res" and return the result.
+ */
+static __isl_give isl_union_map *bin_add_map(__isl_take isl_union_map *res,
+  __isl_keep isl_map *map)
 {
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_map *map = *entry;
+  return isl_union_map_add_map(res, isl_map_copy(map));
+}
 
-  hash = isl_space_get_hash(map->dim);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, map->dim, 0);
-  map = isl_map_copy(map);
-  if (entry2) {
-    int empty;
-    map = isl_map_subtract(map, isl_map_copy(entry2->data));
+/* Combine "map1" and "map2", add the result to "res" and return the result.
+ * Check whether the result is empty before adding it to "res".
+ */
+static __isl_give isl_union_map *bin_add_pair(__isl_take isl_union_map *res,
+  __isl_keep isl_map *map1, __isl_keep isl_map *map2,
+  struct isl_union_map_gen_bin_data *data)
+{
+  isl_bool empty;
+  isl_map *map;
 
-    empty = isl_map_is_empty(map);
-    if (empty < 0) {
-      isl_map_free(map);
-      return isl_stat_error;
-    }
-    if (empty) {
-      isl_map_free(map);
-      return isl_stat_ok;
-    }
-  }
-  data->res = isl_union_map_add_map(data->res, map);
+  map = data->control->fn_map(isl_map_copy(map1), isl_map_copy(map2));
+  if (empty < 0 || empty) {
+    if (empty < 0)
+      return isl_union_map_free(res);
+    return res;
+  return isl_union_map_add_map(res, map);
+
+/* Dummy match_space function that simply returns the input space.
+ */
+static __isl_give isl_space *identity(__isl_take isl_space *space)
+{
+  return space;
+
+/* Look for the map in data->umap2 that corresponds to "map", if any.
+ * Return (isl_bool_true, matching map) if there is one,
+ * (isl_bool_false, NULL) if there is no matching map and
+ * (isl_bool_error, NULL) on error.
+ *
+ * If not NULL, then data->control->filter specifies whether "map"
+ * can have any matching map.  If so,
+ * data->control->match_space specifies which map in data->umap2
+ * corresponds to "map".
+ */
+static __isl_keep isl_maybe_isl_map bin_try_get_match(
+  struct isl_union_map_gen_bin_data *data, __isl_keep isl_map *map)
+{
+  uint32_t hash;
+  struct isl_hash_table_entry *entry2;
+  isl_space *space;
+  isl_maybe_isl_map res = { isl_bool_error, NULL };
+
+  if (data->control->filter) {
+    res.valid = data->control->filter(map);
+    if (res.valid < 0 || !res.valid)
+      return res;
+    res.valid = isl_bool_error;
+  }
+
+  space = isl_map_get_space(map);
+  if (data->control->match_space != &identity)
+    space = data->control->match_space(space);
+  if (!space)
+    return res;
+  hash = isl_space_get_hash(space);
+  entry2 = isl_hash_table_find(isl_union_map_get_ctx(data->umap2),
+             &data->umap2->table, hash,
+             &has_space, space, 0);
+  isl_space_free(space);
+  res.valid = entry2 != NULL;
+  if (entry2)
+    res.value = entry2->data;
+
+  return res;
+}
+
+/* isl_hash_table_foreach callback for gen_bin_op.
+ * Look for the map in data->umap2 that corresponds
+ * to the map that "entry" points to, apply the binary operation and
+ * add the result to data->res.
+ *
+ * If no corresponding map can be found, then the effect depends
+ * on data->control->subtract.  If it is set, then the current map
+ * is added directly to the result.  Otherwise, it is ignored.
+ */
+static isl_stat gen_bin_entry(void **entry, void *user)
+{
+  struct isl_union_map_gen_bin_data *data = user;
+  isl_map *map = *entry;
+  isl_maybe_isl_map m;
+
+  m = bin_try_get_match(data, map);
+  if (m.valid < 0)
+    return isl_stat_error;
+  if (!m.valid && !data->control->subtract)
+    return isl_stat_ok;
+
+  if (!m.valid)
+    data->res = bin_add_map(data->res, map);
+  else
+    data->res = bin_add_pair(data->res, map, m.value, data);
+  if (!data->res)
+    return isl_stat_error;
 
   return isl_stat_ok;
 }
 
+/* Apply a binary operation to "umap1" and "umap2" based on "control".
+ * Run over all maps in "umap1" and look for the corresponding map in "umap2"
+ * in gen_bin_entry.
+ */
 static __isl_give isl_union_map *gen_bin_op(__isl_take isl_union_map *umap1,
-  __isl_take isl_union_map *umap2, isl_stat (*fn)(void **, void *))
+  __isl_take isl_union_map *umap2, struct isl_bin_op_control *control)
 {
-  struct isl_union_map_gen_bin_data data = { NULL, NULL };
+  struct isl_union_map_gen_bin_data data = { control, NULL, NULL };
 
   umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
   umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
 
   if (!umap1 || !umap2)
     goto error;
 
   data.umap2 = umap2;
   data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
                umap1->table.n);
   if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
-           fn, &data) < 0)
+           &gen_bin_entry, &data) < 0)
     goto error;
 
   isl_union_map_free(umap1);
   isl_union_map_free(umap2);
   return data.res;
 error:
   isl_union_map_free(umap1);
   isl_union_map_free(umap2);
   isl_union_map_free(data.res);
   return NULL;
 }
 
 __isl_give isl_union_map *isl_union_map_subtract(
   __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 {
-  return gen_bin_op(umap1, umap2, &subtract_entry);
+  struct isl_bin_op_control control = {
+    .subtract = 1,
+    .match_space = &identity,
+    .fn_map = &isl_map_subtract,
+  };
+
+  return gen_bin_op(umap1, umap2, &control);
 }
 
 __isl_give isl_union_set *isl_union_set_subtract(
   __isl_take isl_union_set *uset1, __isl_take isl_union_set *uset2)
 {
   return isl_union_map_subtract(uset1, uset2);
 }
 
static isl_stat match_bin_entry(void **entry, void *user)
   struct isl_union_map_match_bin_data *data = user;
   uint32_t hash;
   struct isl_hash_table_entry *entry2;
   isl_map *map = *entry;
   int empty;
 
   hash = isl_space_get_hash(map->dim);
   entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, map->dim, 0);
+             hash, &has_space, map->dim, 0);
   if (!entry2)
     return isl_stat_ok;
 
   map = isl_map_copy(map);
   map = data->fn(map, isl_map_copy(entry2->data));
 
   empty = isl_map_is_empty(map);
   if (empty < 0) {

 __isl_give isl_union_set *isl_union_set_gist(__isl_take isl_union_set *uset,
   __isl_take isl_union_set *context)
 {
   if (isl_union_set_is_params(context))
     return union_map_gist_params(uset, context);
   return isl_union_map_gist(uset, context);
 }
 
+/* For each map in "umap", remove the constraints in the corresponding map
+ * of "context".
+ * Each map in "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_union_map *isl_union_map_plain_gist(
+  __isl_take isl_union_map *umap, __isl_take isl_union_map *context)
+{
+  return match_bin_op(umap, context, &isl_map_plain_gist);
+}
+
+/* For each set in "uset", remove the constraints in the corresponding set
+ * of "context".
+ * Each set in "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_union_set *isl_union_set_plain_gist(
+  __isl_take isl_union_set *uset, __isl_take isl_union_set *context)
+{
+  return isl_union_map_plain_gist(uset, context);
+}
+
 static __isl_give isl_map *lex_le_set(__isl_take isl_map *set1,
   __isl_take isl_map *set2)
 {
   return isl_set_lex_le_set(set_from_map(set1), set_from_map(set2));
 }
 
 static __isl_give isl_map *lex_lt_set(__isl_take isl_map *set1,
   __isl_take isl_map *set2)

 }
 
 __isl_give isl_union_map *isl_union_map_lex_ge_union_map(
   __isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 {
   return isl_union_map_reverse(isl_union_map_lex_le_union_map(umap2, umap1));
 }
 
-static isl_stat intersect_domain_entry(void **entry, void *user)
+/* Intersect the domain of "umap" with "uset".
+ */
+static __isl_give isl_union_map *union_map_intersect_domain(
+  __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *dim;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  dim = isl_map_get_space(map);
-  dim = isl_space_domain(dim);
-  hash = isl_space_get_hash(dim);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, dim, 0);
-  isl_space_free(dim);
-  if (!entry2)
-    return isl_stat_ok;
-
-  map = isl_map_copy(map);
-  map = isl_map_intersect_domain(map, isl_set_copy(entry2->data));
-
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
-  if (empty) {
-    isl_map_free(map);
-    return isl_stat_ok;
-  }
-
-  data->res = isl_union_map_add_map(data->res, map);
+  struct isl_bin_op_control control = {
+    .match_space = &isl_space_domain,
+    .fn_map = &isl_map_intersect_domain,
+  };
 
-  return isl_stat_ok;
+  return gen_bin_op(umap, uset, &control);
 }
 
 /* Intersect the domain of "umap" with "uset".
  * If "uset" is a parameters domain, then intersect the parameter
  * domain of "umap" with this set.
  */
 __isl_give isl_union_map *isl_union_map_intersect_domain(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
   if (isl_union_set_is_params(uset))
     return union_map_intersect_params(umap, uset);
-  return gen_bin_op(umap, uset, &intersect_domain_entry);
-}
-
-/* Remove the elements of data->umap2 from the domain of *entry
- * and add the result to data->res.
- */
-static isl_stat subtract_domain_entry(void **entry, void *user)
-{
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *dim;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  dim = isl_map_get_space(map);
-  dim = isl_space_domain(dim);
-  hash = isl_space_get_hash(dim);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, dim, 0);
-  isl_space_free(dim);
-
-  map = isl_map_copy(map);
-
-  if (!entry2) {
-    data->res = isl_union_map_add_map(data->res, map);
-    return isl_stat_ok;
-  }
-
-  map = isl_map_subtract_domain(map, isl_set_copy(entry2->data));
-
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
-  if (empty) {
-    isl_map_free(map);
-    return isl_stat_ok;
-  }
-
-  data->res = isl_union_map_add_map(data->res, map);
-
-  return isl_stat_ok;
+  else
+    return union_map_intersect_domain(umap, uset);
 }
 
 /* Remove the elements of "uset" from the domain of "umap".
  */
 __isl_give isl_union_map *isl_union_map_subtract_domain(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *dom)
 {
-  return gen_bin_op(umap, dom, &subtract_domain_entry);
-}
-
-/* Remove the elements of data->umap2 from the range of *entry
- * and add the result to data->res.
- */
-static isl_stat subtract_range_entry(void **entry, void *user)
-{
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *space;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  space = isl_map_get_space(map);
-  space = isl_space_range(space);
-  hash = isl_space_get_hash(space);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, space, 0);
-  isl_space_free(space);
-
-  map = isl_map_copy(map);
-
-  if (!entry2) {
-    data->res = isl_union_map_add_map(data->res, map);
-    return isl_stat_ok;
-  }
-
-  map = isl_map_subtract_range(map, isl_set_copy(entry2->data));
+  struct isl_bin_op_control control = {
+    .subtract = 1,
+    .match_space = &isl_space_domain,
+    .fn_map = &isl_map_subtract_domain,
+  };
 
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
-  if (empty) {
-    isl_map_free(map);
-    return isl_stat_ok;
-  }
-
-  data->res = isl_union_map_add_map(data->res, map);
-
-  return isl_stat_ok;
+  return gen_bin_op(umap, dom, &control);
 }
 
 /* Remove the elements of "uset" from the range of "umap".
  */
 __isl_give isl_union_map *isl_union_map_subtract_range(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *dom)
 {
-  return gen_bin_op(umap, dom, &subtract_range_entry);
-}
-
-static isl_stat gist_domain_entry(void **entry, void *user)
-{
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *dim;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  dim = isl_map_get_space(map);
-  dim = isl_space_domain(dim);
-  hash = isl_space_get_hash(dim);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, dim, 0);
-  isl_space_free(dim);
-  if (!entry2)
-    return isl_stat_ok;
-
-  map = isl_map_copy(map);
-  map = isl_map_gist_domain(map, isl_set_copy(entry2->data));
+  struct isl_bin_op_control control = {
+    .subtract = 1,
+    .match_space = &isl_space_range,
+    .fn_map = &isl_map_subtract_range,
+  };
 
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
+  return gen_bin_op(umap, dom, &control);
 
-  data->res = isl_union_map_add_map(data->res, map);
+/* Compute the gist of "umap" with respect to the domain "uset".
+ */
+static __isl_give isl_union_map *union_map_gist_domain(
+  __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
+{
+  struct isl_bin_op_control control = {
+    .match_space = &isl_space_domain,
+    .fn_map = &isl_map_gist_domain,
+  };
 
-  return isl_stat_ok;
+  return gen_bin_op(umap, uset, &control);
 }
 
 /* Compute the gist of "umap" with respect to the domain "uset".
  * If "uset" is a parameters domain, then compute the gist
  * with respect to this parameter domain.
  */
 __isl_give isl_union_map *isl_union_map_gist_domain(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
   if (isl_union_set_is_params(uset))
     return union_map_gist_params(umap, uset);
-  return gen_bin_op(umap, uset, &gist_domain_entry);
-}
-
-static isl_stat gist_range_entry(void **entry, void *user)
-{
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *space;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  space = isl_map_get_space(map);
-  space = isl_space_range(space);
-  hash = isl_space_get_hash(space);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, space, 0);
-  isl_space_free(space);
-  if (!entry2)
-    return isl_stat_ok;
-
-  map = isl_map_copy(map);
-  map = isl_map_gist_range(map, isl_set_copy(entry2->data));
-
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
-
-  data->res = isl_union_map_add_map(data->res, map);
-
-  return isl_stat_ok;
+  else
+    return union_map_gist_domain(umap, uset);
 }
 
 /* Compute the gist of "umap" with respect to the range "uset".
  */
 __isl_give isl_union_map *isl_union_map_gist_range(
   __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-  return gen_bin_op(umap, uset, &gist_range_entry);
-}
-
-static isl_stat intersect_range_entry(void **entry, void *user)
-{
-  struct isl_union_map_gen_bin_data *data = user;
-  uint32_t hash;
-  struct isl_hash_table_entry *entry2;
-  isl_space *dim;
-  isl_map *map = *entry;
-  isl_bool empty;
-
-  dim = isl_map_get_space(map);
-  dim = isl_space_range(dim);
-  hash = isl_space_get_hash(dim);
-  entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, dim, 0);
-  isl_space_free(dim);
-  if (!entry2)
-    return isl_stat_ok;
-
-  map = isl_map_copy(map);
-  map = isl_map_intersect_range(map, isl_set_copy(entry2->data));
+  struct isl_bin_op_control control = {
+    .match_space = &isl_space_range,
+    .fn_map = &isl_map_gist_range,
+  };
 
-  empty = isl_map_is_empty(map);
-  if (empty < 0) {
-    isl_map_free(map);
-    return isl_stat_error;
-  }
-  if (empty) {
-    isl_map_free(map);
-    return isl_stat_ok;
-  }
+  return gen_bin_op(umap, uset, &control);
 
-  data->res = isl_union_map_add_map(data->res, map);
+__isl_give isl_union_map *isl_union_map_intersect_range(
+  __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
+{
+  struct isl_bin_op_control control = {
+    .match_space = &isl_space_range,
+    .fn_map = &isl_map_intersect_range,
+  };
 
-  return isl_stat_ok;
+  return gen_bin_op(umap, uset, &control);
 }
 
-__isl_give isl_union_map *isl_union_map_intersect_range(
-  __isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
+/* Intersect each map in "umap" in a space A -> [B -> C]
+ * with the corresponding map in "factor" in the space A -> C and
+ * collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_range(
+  __isl_take isl_union_map *umap, __isl_take isl_union_map *factor)
 {
-  return gen_bin_op(umap, uset, &intersect_range_entry);
+  struct isl_bin_op_control control = {
+    .filter = &isl_map_range_is_wrapping,
+    .match_space = &isl_space_range_factor_range,
+    .fn_map = &isl_map_intersect_range_factor_range,
+  };
+
+  return gen_bin_op(umap, factor, &control);
 }
 
 struct isl_union_map_bin_data {
   isl_union_map *umap2;
   isl_union_map *res;
   isl_map *map;
   isl_stat (*fn)(void **entry, void *user);
 };

 }
 
 __isl_give isl_union_set *isl_union_set_affine_hull(
   __isl_take isl_union_set *uset)
 {
   return isl_union_map_affine_hull(uset);
 }
 
+/* Wrapper around isl_set_combined_lineality_space
+ * that returns the combined lineality space in the form of an isl_set
+ * instead of an isl_basic_set.
+ */
+static __isl_give isl_set *combined_lineality_space(__isl_take isl_set *set)
+{
+  return isl_set_from_basic_set(isl_set_combined_lineality_space(set));
+}
+
+/* For each set in "uset", compute the (linear) hull
+ * of the lineality spaces of its basic sets and
+ * collect and return the results.
+ */
+__isl_give isl_union_set *isl_union_set_combined_lineality_space(
+  __isl_take isl_union_set *uset)
+{
+  struct isl_un_op_control control = {
+    .fn_map = &combined_lineality_space,
+  };
+  return un_op(uset, &control);
+}
+
 /* Compute the polyhedral hull of "map" and return the result as an isl_map.
  */
 static __isl_give isl_map *isl_map_polyhedral_hull_map(__isl_take isl_map *map)
 {
   return isl_map_from_basic_map(isl_map_polyhedral_hull(map));
 }
 
 __isl_give isl_union_map *isl_union_map_polyhedral_hull(

 {
   struct isl_union_map_is_subset_data *data = user;
   uint32_t hash;
   struct isl_hash_table_entry *entry2;
   isl_map *map = *entry;
 
   hash = isl_space_get_hash(map->dim);
   entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, map->dim, 0);
+             hash, &has_space, map->dim, 0);
   if (!entry2) {
     int empty = isl_map_is_empty(map);
     if (empty < 0)
       return isl_stat_error;
     if (empty)
       return isl_stat_ok;
     data->is_subset = 0;
     return isl_stat_error;

 {
   struct isl_union_map_is_disjoint_data *data = user;
   uint32_t hash;
   struct isl_hash_table_entry *entry2;
   isl_map *map = *entry;
 
   hash = isl_space_get_hash(map->dim);
   entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-             hash, &has_dim, map->dim, 0);
+             hash, &has_space, map->dim, 0);
   if (!entry2)
     return isl_stat_ok;
 
   data->is_disjoint = isl_map_is_disjoint(map, entry2->data);
   if (data->is_disjoint < 0 || !data->is_disjoint)
     return isl_stat_error;
 
   return isl_stat_ok;

polly/trunk/lib/External/isl/isl_union_set_private.h

+#ifndef ISL_UNION_SET_PRIVATE_H
+#define ISL_UNION_SET_PRIVATE_H
+
+#include <isl/union_set.h>
+
+__isl_give isl_union_set *isl_union_set_combined_lineality_space(
+  __isl_take isl_union_set *uset);
+__isl_give isl_union_set *isl_union_set_plain_gist(
+  __isl_take isl_union_set *uset, __isl_take isl_union_set *context);
+
+#endif

polly/trunk/lib/External/isl/isl_val.c

__isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
   return v1;
 error:
   isl_val_free(v1);
   isl_val_free(v2);
   return NULL;
 }
 
 /* Divide "v1" by "v2".
+ */
+__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
+{
+  if (!v1)
+    return NULL;
+  if (isl_val_is_nan(v1))
+    return v1;
+  if (v2 == 0)
+    return isl_val_set_nan(v1);
+  if (v2 == 1)
+    return v1;
+  if (isl_val_is_zero(v1))
+    return v1;
+  if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
+    return v1;
+  v1 = isl_val_cow(v1);
+  if (!v1)
+    return NULL;
+
+  isl_int_mul_ui(v1->d, v1->d, v2);
+
+  return isl_val_normalize(v1);
+}
+
+/* Divide "v1" by "v2".
  *
  * This is a private copy of isl_val_div for use in the generic
  * isl_multi_*_scale_down_val instantiated for isl_val.
  */
 __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
   __isl_take isl_val *v2)
 {
   return isl_val_div(v1, v2);

polly/trunk/lib/External/isl/isl_vec.c

int isl_vec_cmp_element(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2,
   if (!vec1 || !vec2)
     return 0;
   if (pos < 0 || pos >= vec1->size || pos >= vec2->size)
     isl_die(isl_vec_get_ctx(vec1), isl_error_invalid,
       "position out of range", return 0);
   return isl_int_cmp(vec1->el[pos], vec2->el[pos]);
 }
 
+/* Does "vec" contain only zero elements?
+ */
+isl_bool isl_vec_is_zero(__isl_keep isl_vec *vec)
+{
+  if (!vec)
+    return isl_bool_error;
+  return isl_seq_first_non_zero(vec->el, vec->size) < 0;
+}
+
 isl_bool isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2)
 {
   if (!vec1 || !vec2)
     return isl_bool_error;
 
   if (vec1->size != vec2->size)
     return isl_bool_false;
 

polly/trunk/lib/External/isl/isl_vec_private.h

 uint32_t isl_vec_get_hash(__isl_keep isl_vec *vec);
 
 __isl_give isl_vec *isl_vec_cow(__isl_take isl_vec *vec);
 
 void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm);
 int isl_vec_get_element(__isl_keep isl_vec *vec, int pos, isl_int *v);
 __isl_give isl_vec *isl_vec_set(__isl_take isl_vec *vec, isl_int v);
 
+isl_bool isl_vec_is_zero(__isl_keep isl_vec *vec);
+
 __isl_give isl_vec *isl_vec_expand(__isl_take isl_vec *vec, int pos, int n,
   int *exp, int expanded);
 
 #endif

polly/trunk/lib/External/isl/ltmain.sh

 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 PROGRAM=libtool
 PACKAGE=libtool
-VERSION="2.4.6 Debian-2.4.6-1"
+VERSION="2.4.6 Debian-2.4.6-2"
 package_revision=2.4.6
 
 
 ## ------ ##
 ## Usage. ##
 ## ------ ##
 
 # Run './libtool --help' for help with using this script from the

 # mode: shell-script
 # sh-indentation: 2
 # eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
 # time-stamp-time-zone: "UTC"
 # End:
 
 # Set a version string.
-scriptversion='(GNU libtool) 2.4.6 Debian-2.4.6-1'
+scriptversion='(GNU libtool) 2.4.6'
 
 
 # func_echo ARG...
 # ----------------
 # Libtool also displays the current mode in messages, so override
 # funclib.sh func_echo with this custom definition.
 func_echo ()
 {

 When reporting a bug, please describe a test case to reproduce it and
 include the following information:
 
        host-triplet:   $host
        shell:          $SHELL
        compiler:       $LTCC
        compiler flags: $LTCFLAGS
        linker:         $LD (gnu? $with_gnu_ld)
-       version:        $progname $scriptversion
+       version:        $progname $scriptversion Debian-2.4.6-2
        automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
        autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
 
 Report bugs to <[e-mail]>.
 GNU libtool home page: <http://www.gnu.org/s/libtool/>.
 General help using GNU software: <http://www.gnu.org/gethelp/>."
     exit 0
 }

polly/trunk/lib/External/isl/m4/ax_detect_clang.m4

AC_EGREP_HEADER([setMainFileID], [clang/Basic/SourceManager.h],
   [Define if SourceManager has a setMainFileID method])])
 AC_CHECK_HEADER([llvm/ADT/OwningPtr.h],
   [AC_DEFINE([HAVE_ADT_OWNINGPTR_H], [],
        [Define if llvm/ADT/OwningPtr.h exists])])
 AC_EGREP_HEADER([initializeBuiltins],
   [clang/Basic/Builtins.h], [],
   [AC_DEFINE([initializeBuiltins], [InitializeBuiltins],
     [Define to InitializeBuiltins for older versions of clang])])
+AC_EGREP_HEADER([IK_C], [clang/Frontend/FrontendOptions.h], [],
+   [AC_DEFINE([IK_C], [InputKind::C],
+      [Define to InputKind::C for newer versions of clang])])
 AC_TRY_COMPILE([
   #include <clang/Basic/TargetOptions.h>
   #include <clang/Lex/PreprocessorOptions.h>
   #include <clang/Frontend/CompilerInstance.h>
 ], [
   using namespace clang;
   CompilerInstance *Clang;
   TargetOptions TO;

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ T[9] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop-tree.flow

+must_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop.ai

+sink: { S[] -> a[] }
+must_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { T[9] -> a[] }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop.flow

+must_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop2-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ K[] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[]; K[] }"
+  child:
+    sequence:
+    - filter: "{ T[i]; K[] }"
+      child:
+        schedule: "[{ T[i] -> [(i)]; K[] -> [(10)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop2-tree.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop2.ai

+sink: { S[] -> a[] }
+must_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { K[] -> a[] }
+schedule_map: { T[i] -> [0,i]; K[] -> [0,10]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop2.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop3-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ K[] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[]; K[] }"
+  child:
+    sequence:
+    - filter: "{ T[i]; K[] }"
+      child:
+        schedule: "[{ T[i] -> [(i)]; K[] -> [(9)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop3-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop3.ai

+sink: { S[] -> a[] }
+must_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { K[] -> a[] }
+schedule_map: { T[i] -> [0,i]; K[] -> [0,9]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_loop3.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop-tree.ai

+sink: "{ S[] -> a[] }"
+may_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ T[4] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop.ai

+sink: { S[] -> a[] }
+may_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { T[4] -> a[] }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop2-tree.ai

+sink: "{ S[] -> a[] }"
+may_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ T[9] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop2-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop2.ai

+sink: { S[] -> a[] }
+may_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { T[9] -> a[] }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop2.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop3-tree.ai

+sink: "{ S[] -> a[] }"
+may_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+kill: "{ K[] -> a[] }"
+schedule:
+  domain: "{ T[i]; S[]; K[] }"
+  child:
+    sequence:
+    - filter: "{ T[i]; K[] }"
+      child:
+        schedule: "[{ T[i] -> [(i)]; K[] -> [(4)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop3-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop3.ai

+sink: { S[] -> a[] }
+may_source: { T[i] -> a[] : 0 <= i < 10 }
+kill: { K[] -> a[] }
+schedule_map: { T[i] -> [0,i]; K[] -> [0,4]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/kill_may_loop3.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/loop-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/loop-tree.flow

+must_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/loop.ai

+sink: { S[] -> a[] }
+must_source: { T[i] -> a[] : 0 <= i < 10 }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/loop.flow

+must_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/may_loop-tree.ai

+sink: "{ S[] -> a[] }"
+may_source: "{ T[i] -> a[] : 0 <= i <= 9 }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/may_loop-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 0 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/may_loop.ai

+sink: { S[] -> a[] }
+may_source: { T[i] -> a[] : 0 <= i < 10 }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/may_loop.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i] -> [S[] -> a[]] : 0 <= i <= 9 }"
+must_no_source: "{  }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/mixed_loop-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[i] -> a[] : 2*floor((i)/2) = i and 0 <= i <= 9 }"
+may_source: "{ T[i] -> a[] : 2*floor((1 + i)/2) = 1 + i and 0 <= i <= 9 }"
+schedule:
+  domain: "{ T[i]; S[] }"
+  child:
+    sequence:
+    - filter: "{ T[i] }"
+      child:
+        schedule: "[{ T[i] -> [(i)] }]"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/mixed_loop-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]]; T[i = 8] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/mixed_loop.ai

+sink: { S[] -> a[] }
+must_source: { T[i] -> a[] : 0 <= i < 10 and i mod 2 = 0 }
+may_source: { T[i] -> a[] : 0 <= i < 10 and i mod 2 = 1 }
+schedule_map: { T[i] -> [0,i]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/mixed_loop.flow

+must_dependence: "{  }"
+may_dependence: "{ T[i = 9] -> [S[] -> a[]]; T[i = 8] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi.ai

+sink: "{ [S_2[] -> __pet_ref_4[]] -> a[] }"
+must_source: "{ [S_0[] -> __pet_ref_0[]] -> a[]; [S_2[] -> __pet_ref_3[]] -> b[]; [S_1[] -> __pet_ref_1[]] -> a[]; [S_1[] -> __pet_ref_2[]] -> a[] }"
+may_source: "{ [S_1[] -> __pet_ref_2[]] -> a[]; [S_1[] -> __pet_ref_1[]] -> a[]; [S_2[] -> __pet_ref_3[]] -> b[]; [S_0[] -> __pet_ref_0[]] -> a[] }"
+schedule:
+  domain: "{ [S_1[] -> __pet_ref_1[]]; [S_1[] -> __pet_ref_2[]]; [S_2[] -> __pet_ref_3[]]; [S_0[] -> __pet_ref_0[]]; [S_2[] -> __pet_ref_4[]] }"
+  child:
+    sequence:
+    - filter: "{ [S_0[] -> __pet_ref_0[]] }"
+    - filter: "{ [S_1[] -> __pet_ref_1[]]; [S_1[] -> __pet_ref_2[]] }"
+    - filter: "{ [S_2[] -> __pet_ref_3[]]; [S_2[] -> __pet_ref_4[]] }"

polly/trunk/lib/External/isl/test_inputs/flow/multi.flow

+must_dependence: "{  }"
+may_dependence: "{ [S_1[] -> __pet_ref_2[]] -> [[S_2[] -> __pet_ref_4[]] -> a[]]; [S_1[] -> __pet_ref_1[]] -> [[S_2[] -> __pet_ref_4[]] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[]; U[] -> a[] }"
+schedule:
+  domain: "{ U[]; S[]; T[] }"
+  child:
+    sequence:
+    - filter: "{ T[]; U[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[]; U[] -> a[] }
+schedule_map: { T[] -> [0]; U[] -> [0]; S[] -> [1] }

polly/trunk/lib/External/isl/test_inputs/flow/multi_source.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source2-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[] }"
+may_source: "{ U[] -> a[] }"
+schedule:
+  domain: "{ U[]; S[]; T[] }"
+  child:
+    sequence:
+    - filter: "{ T[]; U[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source2-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source2.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[] }
+may_source: { U[] -> a[] }
+schedule_map: { T[] -> [0]; U[] -> [0]; S[] -> [1] }

polly/trunk/lib/External/isl/test_inputs/flow/multi_source2.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source3-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[]; U[] -> a[] }"
+may_source: "{ V[] -> a[] }"
+schedule:
+  domain: "{ S[]; U[]; T[]; V[] }"
+  child:
+    sequence:
+    - filter: "{ U[]; T[]; V[] }"
+      child:
+        sequence:
+        - filter: "{ T[]; U[] }"
+        - filter: "{ V[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source3-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source3.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[]; U[] -> a[] }
+may_source: { V[] -> a[] }
+schedule_map: { T[] -> [0,0]; U[] -> [0,0]; V[] -> [0,1]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/multi_source3.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source4-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[]; U[] -> a[] }"
+may_source: "{ V[] -> a[] }"
+schedule:
+  domain: "{ S[]; U[]; T[]; V[] }"
+  child:
+    sequence:
+    - filter: "{ U[]; T[]; V[] }"
+      child:
+        sequence:
+        - filter: "{ U[] }"
+        - filter: "{ V[]; T[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source4-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/multi_source4.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[]; U[] -> a[] }
+may_source: { V[] -> a[] }
+schedule_map: { T[] -> [0,1]; U[] -> [0,0]; V[] -> [0,1]; S[] -> [1,0] }

polly/trunk/lib/External/isl/test_inputs/flow/multi_source4.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source-tree.ai

+sink: "{ S[] -> a[] }"
+schedule:
+  domain: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source-tree.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{ S[] -> a[] }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source.ai

+sink: { S[] -> a[] }
+schedule_map: { S[] -> [] }

polly/trunk/lib/External/isl/test_inputs/flow/no_source.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{ S[] -> a[] }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source2-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[] }"
+schedule:
+  domain: "{ S[]; T[] }"
+  child:
+    sequence:
+    - filter: "{ S[] }"
+    - filter: "{ T[] }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source2-tree.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{ S[] -> a[] }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/no_source2.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[] }
+schedule_map: { T[] -> [1]; S[] -> [0] }

polly/trunk/lib/External/isl/test_inputs/flow/no_source2.flow

+must_dependence: "{  }"
+may_dependence: "{  }"
+must_no_source: "{ S[] -> a[] }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/single_may_source-tree.ai

+sink: "{ S[] -> a[] }"
+may_source: "{ T[] -> a[] }"
+schedule:
+  domain: "{ S[]; T[] }"
+  child:
+    sequence:
+    - filter: "{ T[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/single_may_source-tree.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/single_may_source.ai

+sink: { S[] -> a[] }
+may_source: { T[] -> a[] }
+schedule_map: { T[] -> [0]; S[] -> [1] }

polly/trunk/lib/External/isl/test_inputs/flow/single_may_source.flow

+must_dependence: "{  }"
+may_dependence: "{ T[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{ S[] -> a[] }"

polly/trunk/lib/External/isl/test_inputs/flow/single_source-tree.ai

+sink: "{ S[] -> a[] }"
+must_source: "{ T[] -> a[] }"
+schedule:
+  domain: "{ S[]; T[] }"
+  child:
+    sequence:
+    - filter: "{ T[] }"
+    - filter: "{ S[] }"

polly/trunk/lib/External/isl/test_inputs/flow/single_source-tree.flow

+must_dependence: "{ T[] -> [S[] -> a[]] }"
+may_dependence: "{ T[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/lib/External/isl/test_inputs/flow/single_source.ai

+sink: { S[] -> a[] }
+must_source: { T[] -> a[] }
+schedule_map: { T[] -> [0]; S[] -> [1] }

polly/trunk/lib/External/isl/test_inputs/flow/single_source.flow

+must_dependence: "{ T[] -> [S[] -> a[]] }"
+may_dependence: "{ T[] -> [S[] -> a[]] }"
+must_no_source: "{  }"
+may_no_source: "{  }"

polly/trunk/test/DependenceInfo/different_schedule_dimensions.ll

 ; CHECK: WAW dependences:
 ; CHECK:   { Stmt_bb3[0] -> Stmt_bb10[0] }
 ; CHECK: Reduction dependences:
 ; CHECK:   {  }
 
 ; FUNC: RAW dependences:
 ; FUNC-NEXT:   { Stmt_bb9[0] -> Stmt_bb10[0]; [Stmt_bb9[0] -> Stmt_bb9_Write0[]] -> [Stmt_bb10[0] -> Stmt_bb10_Read0[]] }
 ; FUNC-NEXT: WAR dependences:
-; FUNC-NEXT:   { }
+; FUNC-NEXT:   { [Stmt_bb3[0] -> Stmt_bb3_Read0[]] -> [Stmt_bb10[0] -> Stmt_bb10_Write1[]]; Stmt_bb3[0] -> Stmt_bb10[0] }
 ; FUNC-NEXT: WAW dependences:
 ; FUNC-NEXT:   { Stmt_bb3[0] -> Stmt_bb10[0]; [Stmt_bb3[0] -> Stmt_bb3_Write1[]] -> [Stmt_bb10[0] -> Stmt_bb10_Write1[]] }
 ; FUNC-NEXT: Reduction dependences:
 ; FUNC-NEXT:   {  }
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @hoge(i32 %arg, [1024 x double]* %arg1) {

polly/trunk/test/DependenceInfo/do_pluto_matmult.ll

 ; MEMORY-NEXT: WAR dependences:
 ; MEMORY-NEXT:     { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35 }
 ; MEMORY-NEXT: WAW dependences:
 ; MEMORY-NEXT:     { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35 }
 
 ; FUNC-VALUE:      RAW dependences:
 ; FUNC-VALUE-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Write3[]] -> [Stmt_do_body2[i0, i1, 1 + i2] -> Stmt_do_body2_Read0[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34 }
 ; FUNC-VALUE-NEXT: WAR dependences:
-; FUNC-VALUE-NEXT:     { }
+; FUNC-VALUE-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Read0[]] -> [Stmt_do_body2[i0, i1, 1 + i2] -> Stmt_do_body2_Write3[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34 }
 ; FUNC-VALUE-NEXT: WAW dependences:
 ; FUNC-VALUE-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Write3[]] -> [Stmt_do_body2[i0, i1, 1 + i2] -> Stmt_do_body2_Write3[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and 0 <= i2 <= 34 }
 
 ; FUNC-MEMORY:      RAW dependences:
 ; FUNC-MEMORY-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Write3[]] -> [Stmt_do_body2[i0, i1, o2] -> Stmt_do_body2_Read0[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35 }
 ; FUNC-MEMORY-NEXT: WAR dependences:
 ; FUNC-MEMORY-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Read0[]] -> [Stmt_do_body2[i0, i1, o2] -> Stmt_do_body2_Write3[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35 }
 ; FUNC-MEMORY-NEXT: WAW dependences:
 ; FUNC-MEMORY-NEXT:     { [Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2_Write3[]] -> [Stmt_do_body2[i0, i1, o2] -> Stmt_do_body2_Write3[]] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35; Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : 0 <= i0 <= 35 and 0 <= i1 <= 35 and i2 >= 0 and i2 < o2 <= 35 }

polly/trunk/test/ScheduleOptimizer/outer_coincidence.ll

 ; CHECK-NEXT:   #pragma minimal dependence distance: 1
 ; CHECK-NEXT:   for (int c1 = 0; c1 < n - 1; c1 += 1)
 ; CHECK-NEXT:     Stmt_for_body3(c0, c1);
 
 ; OUTER:      #pragma minimal dependence distance: 1
 ; OUTER-NEXT: for (int c0 = 0; c0 < m + n - 3; c0 += 1)
 ; OUTER-NEXT:   #pragma simd
 ; OUTER-NEXT:   #pragma known-parallel
-; OUTER-NEXT:   for (int c1 = max(0, -m + c0 + 2); c1 <= min(n - 2, c0); c1 += 1)
-; OUTER-NEXT:     Stmt_for_body3(c0 - c1, c1);
+; OUTER-NEXT:   for (int c1 = max(0, -n + c0 + 2); c1 <= min(m - 2, c0); c1 += 1)
+; OUTER-NEXT:     Stmt_for_body3(c1, c0 - c1);