diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index ec39e2e..33775ac 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1248,6 +1248,7 @@ OBJS = \
 	graphite-clast-to-gimple.o \
 	graphite-dependences.o \
 	graphite-interchange.o \
+	graphite-optimize-isl.o \
 	graphite-poly.o \
 	graphite-scop-detection.o \
 	graphite-sese-to-poly.o \
@@ -2560,6 +2561,9 @@ graphite-sese-to-poly.o : graphite-sese-to-poly.c $(CONFIG_H) \
    $(SYSTEM_H) coretypes.h $(TREE_FLOW_H) $(TREE_DUMP_H) $(CFGLOOP_H) \
    $(TREE_DATA_REF_H) domwalk.h sese.h graphite-poly.h \
    graphite-sese-to-poly.h
+graphite-optimize-isl.o : graphite-optimize-isl.c $(CONFIG_H) $(SYSTEM_H) \
+    coretypes.h $(TREE_FLOW_H) $(CFGLOOP_H) $(TREE_DATA_REF_H) $(SCEV_H) \
+    $(TREE_DUMP_H) sese.h graphite-poly.h
 tree-vect-loop.o: tree-vect-loop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TM_H) $(GGC_H) $(TREE_H) $(BASIC_BLOCK_H) $(TREE_FLOW_H) \
    $(TREE_DUMP_H) $(CFGLOOP_H) $(EXPR_H) $(RECOG_H) $(OPTABS_H) \
diff --git a/gcc/common.opt b/gcc/common.opt
index ad6db61..12f557a 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1219,6 +1219,10 @@ floop-flatten
 Common Ignore
 Does nothing. Preserved for backward compatibility.
 
+floop-nest-optimize
+Common Report Var(flag_loop_optimize_isl) Optimization
+Enable the ISL based loop nest optimizer
+
 fstrict-volatile-bitfields
 Common Report Var(flag_strict_volatile_bitfields) Init(-1)
 Force bitfield accesses to match their type width
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 87e0d1c..5263152 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -373,7 +373,7 @@ Objective-C and Objective-C++ Dialects}.
 -fira-loop-pressure -fno-ira-share-save-slots @gol
 -fno-ira-share-spill-slots -fira-verbose=@var{n} @gol
 -fivopts -fkeep-inline-functions -fkeep-static-consts @gol
--floop-block -floop-interchange -floop-strip-mine @gol
+-floop-block -floop-interchange -floop-strip-mine -floop-nest-optimize @gol
 -floop-parallelize-all -flto -flto-compression-level @gol
 -flto-partition=@var{alg} -flto-report -fmerge-all-constants @gol
 -fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves @gol
@@ -7367,6 +7367,12 @@ GIMPLE -> GRAPHITE -> GIMPLE transformation.  Some minimal optimizations
 are also performed by the code generator CLooG, like index splitting and
 dead code elimination in loops.
 
+@item -floop-nest-optimize
+@opindex floop-nest-optimize
+Enable the ISL based loop nest optimizer. This is a generic loop nest
+optimizer based on the Pluto optimization algorithms. It calculates a loop
+structure optimized for data-locality and parallelism.
+
 @item -floop-parallelize-all
 @opindex floop-parallelize-all
 Use the Graphite data dependence analysis to identify loops that can
diff --git a/gcc/graphite-dependences.c b/gcc/graphite-dependences.c
index 0c10e60..1ef063d 100644
--- a/gcc/graphite-dependences.c
+++ b/gcc/graphite-dependences.c
@@ -443,7 +443,7 @@ subtract_commutative_associative_deps (scop_p scop,
 /* Compute the original data dependences in SCOP for all the reads and
    writes in PBBS.  */
 
-static void
+void
 compute_deps (scop_p scop, VEC (poly_bb_p, heap) *pbbs,
 	      isl_union_map **must_raw,
 	      isl_union_map **may_raw,
diff --git a/gcc/graphite-optimize-isl.c b/gcc/graphite-optimize-isl.c
new file mode 100644
index 0000000..27de86b
--- /dev/null
+++ b/gcc/graphite-optimize-isl.c
@@ -0,0 +1,471 @@
+/* A scheduling optimizer for Graphite
+   Copyright (C) 2012 Free Software Foundation, Inc.
+   Contributed by Tobias Grosser <tobias@grosser.es>.
+
+This file is part of GCC.
+
+GCC 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, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+
+#ifdef HAVE_cloog
+#include <isl/set.h>
+#include <isl/map.h>
+#include <isl/union_map.h>
+#include <isl/schedule.h>
+#include <isl/band.h>
+#include <isl/aff.h>
+#include <isl/options.h>
+
+#include "system.h"
+#include "coretypes.h"
+#include "tree-flow.h"
+#include "tree-dump.h"
+#include "cfgloop.h"
+#include "tree-chrec.h"
+#include "tree-data-ref.h"
+#include "tree-scalar-evolution.h"
+#include "sese.h"
+
+#include "graphite-poly.h"
+
+static isl_union_set *
+scop_get_domains (scop_p scop ATTRIBUTE_UNUSED)
+{
+  int i;
+  poly_bb_p pbb;
+  isl_space *space = isl_set_get_space (scop->context);
+  isl_union_set *res = isl_union_set_empty (space);
+
+  FOR_EACH_VEC_ELT (poly_bb_p, scop->bbs, i, pbb)
+    res = isl_union_set_add_set (res, isl_set_copy (pbb->domain));
+
+  return res;
+}
+
+static isl_union_map *
+scop_get_dependences (scop_p scop ATTRIBUTE_UNUSED)
+{
+  isl_union_map *dependences;
+
+  if (!scop->must_raw)
+    compute_deps (scop, SCOP_BBS (scop),
+		  &scop->must_raw, &scop->may_raw,
+		  &scop->must_raw_no_source, &scop->may_raw_no_source,
+		  &scop->must_war, &scop->may_war,
+		  &scop->must_war_no_source, &scop->may_war_no_source,
+		  &scop->must_waw, &scop->may_waw,
+		  &scop->must_waw_no_source, &scop->may_waw_no_source);
+
+  dependences = isl_union_map_copy (scop->must_raw);
+  dependences = isl_union_map_union (dependences,
+				     isl_union_map_copy (scop->must_war));
+  dependences = isl_union_map_union (dependences,
+				     isl_union_map_copy (scop->must_waw));
+  dependences = isl_union_map_union (dependences,
+				     isl_union_map_copy (scop->may_raw));
+  dependences = isl_union_map_union (dependences,
+				     isl_union_map_copy (scop->may_war));
+  dependences = isl_union_map_union (dependences,
+				     isl_union_map_copy (scop->may_waw));
+
+  return dependences;
+}
+
+/* getTileMap - Create a map that describes a n-dimensonal tiling.
+  
+   getTileMap creates a map from a n-dimensional scattering space into an
+   2*n-dimensional scattering space. The map describes a rectangular tiling.
+  
+   Example:
+     scheduleDimensions = 2, parameterDimensions = 1, tileSize = 32
+ 
+    tileMap := [p0] -> {[s0, s1] -> [t0, t1, s0, s1]:
+                         t0 % 32 = 0 and t0 <= s0 < t0 + 32 and
+                         t1 % 32 = 0 and t1 <= s1 < t1 + 32}
+ 
+   Before tiling:
+ 
+   for (i = 0; i < N; i++)
+     for (j = 0; j < M; j++)
+ 	S(i,j)
+ 
+   After tiling:
+ 
+   for (t_i = 0; t_i < N; i+=32)
+     for (t_j = 0; t_j < M; j+=32)
+ 	for (i = t_i; i < min(t_i + 32, N); i++)  | Unknown that N % 32 = 0
+ 	  for (j = t_j; j < t_j + 32; j++)        |   Known that M % 32 = 0
+ 	    S(i,j)
+   */
+ 
+static isl_basic_map *
+getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize)
+{
+  int x;
+  /* We construct
+
+     tileMap := [p0] -> {[s0, s1] -> [t0, t1, p0, p1, a0, a1]:
+    	                s0 = a0 * 32 and s0 = p0 and t0 <= p0 < t0 + 32 and
+    	                s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32}
+
+     and project out the auxilary dimensions a0 and a1.  */
+  isl_space *Space = isl_space_alloc(ctx, 0, scheduleDimensions,
+				     scheduleDimensions * 3);
+  isl_basic_map *tileMap = isl_basic_map_universe(isl_space_copy(Space));
+
+  isl_local_space *LocalSpace = isl_local_space_from_space(Space);
+
+  for (x = 0; x < scheduleDimensions; x++)
+    {
+      int sX = x;
+      int tX = x;
+      int pX = scheduleDimensions + x;
+      int aX = 2 * scheduleDimensions + x;
+
+      isl_constraint *c;
+
+      /* sX = aX * tileSize; */
+      c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
+      isl_constraint_set_coefficient_si(c, isl_dim_out, sX, 1);
+      isl_constraint_set_coefficient_si(c, isl_dim_out, aX, -tileSize);
+      tileMap = isl_basic_map_add_constraint(tileMap, c);
+
+      /* pX = sX; */
+      c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
+      isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1);
+      isl_constraint_set_coefficient_si(c, isl_dim_in, sX, -1);
+      tileMap = isl_basic_map_add_constraint(tileMap, c);
+
+      /* tX <= pX */
+      c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
+      isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1);
+      isl_constraint_set_coefficient_si(c, isl_dim_out, tX, -1);
+      tileMap = isl_basic_map_add_constraint(tileMap, c);
+
+      /* pX <= tX + (tileSize - 1) */
+      c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
+      isl_constraint_set_coefficient_si(c, isl_dim_out, tX, 1);
+      isl_constraint_set_coefficient_si(c, isl_dim_out, pX, -1);
+      isl_constraint_set_constant_si(c, tileSize - 1);
+      tileMap = isl_basic_map_add_constraint(tileMap, c);
+    }
+
+  /* Project out auxilary dimensions.
+
+     The auxilary dimensions are transformed into existentially quantified ones.
+     This reduces the number of visible scattering dimensions and allows Cloog
+     to produces better code.  */
+  tileMap = isl_basic_map_project_out(tileMap, isl_dim_out,
+				      2 * scheduleDimensions,
+				      scheduleDimensions);
+  isl_local_space_free(LocalSpace);
+  return tileMap;
+}
+
+/* getScheduleForBand - Get the schedule for this band.
+  
+   Polly applies transformations like tiling on top of the isl calculated value.
+   This can influence the number of scheduling dimension. The number of
+   schedule dimensions is returned in the parameter 'Dimension'.  */
+static bool DisableTiling = false;
+
+static isl_union_map *
+getScheduleForBand(isl_band *Band, int *Dimensions)
+{
+  isl_union_map *PartialSchedule;
+  isl_ctx *ctx;
+  isl_space *Space;
+  isl_basic_map *TileMap;
+  isl_union_map *TileUMap;
+
+  PartialSchedule = isl_band_get_partial_schedule(Band);
+  *Dimensions = isl_band_n_member(Band);
+
+  if (DisableTiling)
+    return PartialSchedule;
+
+  /* It does not make any sense to tile a band with just one dimension.  */
+  if (*Dimensions == 1)
+    return PartialSchedule;
+
+  ctx = isl_union_map_get_ctx(PartialSchedule);
+  Space = isl_union_map_get_space(PartialSchedule);
+
+  TileMap = getTileMap(ctx, *Dimensions, 32);
+  TileUMap = isl_union_map_from_map(isl_map_from_basic_map(TileMap));
+  TileUMap = isl_union_map_align_params(TileUMap, Space);
+  *Dimensions = 2 * *Dimensions;
+
+  return isl_union_map_apply_range(PartialSchedule, TileUMap);
+}
+
+/* Create a map that pre-vectorizes one scheduling dimension.
+  
+   getPrevectorMap creates a map that maps each input dimension to the same
+   output dimension, except for the dimension DimToVectorize. DimToVectorize is
+   strip mined by 'VectorWidth' and the newly created point loop of
+   DimToVectorize is moved to the innermost level.
+  
+   Example (DimToVectorize=0, ScheduleDimensions=2, VectorWidth=4):
+  
+   | Before transformation
+   |
+   | A[i,j] -> [i,j]
+   |
+   | for (i = 0; i < 128; i++)
+   |    for (j = 0; j < 128; j++)
+   |      A(i,j);
+  
+     Prevector map:
+     [i,j] -> [it,j,ip] : it % 4 = 0 and it <= ip <= it + 3 and i = ip
+  
+   | After transformation:
+   |
+   | A[i,j] -> [it,j,ip] : it % 4 = 0 and it <= ip <= it + 3 and i = ip
+   |
+   | for (it = 0; it < 128; it+=4)
+   |    for (j = 0; j < 128; j++)
+   |      for (ip = max(0,it); ip < min(128, it + 3); ip++)
+   |        A(ip,j);
+  
+   The goal of this transformation is to create a trivially vectorizable loop.
+   This means a parallel loop at the innermost level that has a constant number
+   of iterations corresponding to the target vector width.
+  
+   This transformation creates a loop at the innermost level. The loop has a
+   constant number of iterations, if the number of loop iterations at
+   DimToVectorize can be devided by VectorWidth. The default VectorWidth is
+   currently constant and not yet target specific. This function does not reason
+   about parallelism.  */
+static isl_map *
+getPrevectorMap(isl_ctx *ctx, int DimToVectorize,
+		int ScheduleDimensions,
+		int VectorWidth)
+{
+  isl_space *Space;
+  isl_local_space *LocalSpace, *LocalSpaceRange;
+  isl_set *Modulo;
+  isl_map *TilingMap;
+  isl_constraint *c;
+  isl_aff *Aff;
+  int PointDimension; /* ip */
+  int TileDimension;  /* it */
+  isl_int VectorWidthMP;
+  int i;
+
+  /* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/
+
+  Space = isl_space_alloc(ctx, 0, ScheduleDimensions, ScheduleDimensions + 1);
+  TilingMap = isl_map_universe(isl_space_copy(Space));
+  LocalSpace = isl_local_space_from_space(Space);
+  PointDimension = ScheduleDimensions;
+  TileDimension = DimToVectorize;
+
+  /* Create an identity map for everything except DimToVectorize and map
+     DimToVectorize to the point loop at the innermost dimension.  */
+  for (i = 0; i < ScheduleDimensions; i++)
+    {
+      c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
+      isl_constraint_set_coefficient_si(c, isl_dim_in, i, -1);
+
+      if (i == DimToVectorize)
+	isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1);
+      else
+	isl_constraint_set_coefficient_si(c, isl_dim_out, i, 1);
+
+      TilingMap = isl_map_add_constraint(TilingMap, c);
+    }
+
+  /* it % 'VectorWidth' = 0  */
+  LocalSpaceRange = isl_local_space_range(isl_local_space_copy(LocalSpace));
+  Aff = isl_aff_zero_on_domain(LocalSpaceRange);
+  Aff = isl_aff_set_constant_si(Aff, VectorWidth);
+  Aff = isl_aff_set_coefficient_si(Aff, isl_dim_in, TileDimension, 1);
+  isl_int_init(VectorWidthMP);
+  isl_int_set_si(VectorWidthMP, VectorWidth);
+  Aff = isl_aff_mod(Aff, VectorWidthMP);
+  isl_int_clear(VectorWidthMP);
+  Modulo = isl_pw_aff_zero_set(isl_pw_aff_from_aff(Aff));
+  TilingMap = isl_map_intersect_range(TilingMap, Modulo);
+
+  /* it <= ip */
+  c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
+  isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, -1);
+  isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1);
+  TilingMap = isl_map_add_constraint(TilingMap, c);
+
+  /* ip <= it + ('VectorWidth' - 1) */
+  c = isl_inequality_alloc(LocalSpace);
+  isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, 1);
+  isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, -1);
+  isl_constraint_set_constant_si(c, VectorWidth - 1);
+  TilingMap = isl_map_add_constraint(TilingMap, c);
+
+  isl_map_dump(TilingMap);
+
+  return TilingMap;
+}
+
+static bool EnablePollyVector = false;
+
+/* getScheduleForBandList - Get the scheduling map for a list of bands.
+    
+   We walk recursively the forest of bands to combine the schedules of the
+   individual bands to the overall schedule. In case tiling is requested,
+   the individual bands are tiled.  */
+static isl_union_map *
+getScheduleForBandList(isl_band_list *BandList)
+{
+  int NumBands, i;
+  isl_union_map *Schedule;
+  isl_ctx *ctx;
+
+  ctx = isl_band_list_get_ctx(BandList);
+  NumBands = isl_band_list_n_band(BandList);
+  Schedule = isl_union_map_empty(isl_space_params_alloc(ctx, 0));
+
+  for (i = 0; i < NumBands; i++)
+    {
+      isl_band *Band;
+      isl_union_map *PartialSchedule;
+      int ScheduleDimensions;
+      isl_space *Space;
+
+      Band = isl_band_list_get_band(BandList, i);
+      PartialSchedule = getScheduleForBand(Band, &ScheduleDimensions);
+      Space = isl_union_map_get_space(PartialSchedule);
+
+      if (isl_band_has_children(Band))
+	{
+	  isl_band_list *Children;
+	  isl_union_map *SuffixSchedule;
+
+	  Children = isl_band_get_children(Band);
+	  SuffixSchedule = getScheduleForBandList(Children);
+	  PartialSchedule = isl_union_map_flat_range_product(PartialSchedule,
+							     SuffixSchedule);
+	  isl_band_list_free(Children);
+	}
+      else if (EnablePollyVector)
+	{
+	  for (i = ScheduleDimensions - 1 ;  i >= 0 ; i--)
+	    {
+	      if (isl_band_member_is_zero_distance(Band, i))
+		{
+		  isl_map *TileMap;
+		  isl_union_map *TileUMap;
+
+		  TileMap = getPrevectorMap(ctx, i, ScheduleDimensions, 4);
+		  TileUMap = isl_union_map_from_map(TileMap);
+		  TileUMap = isl_union_map_align_params(TileUMap,
+							isl_space_copy(Space));
+		  PartialSchedule = isl_union_map_apply_range(PartialSchedule,
+							      TileUMap);
+		  break;
+		}
+	    }
+	}
+
+      Schedule = isl_union_map_union(Schedule, PartialSchedule);
+
+      isl_band_free(Band);
+      isl_space_free(Space);
+    }
+
+  return Schedule;
+}
+
+static isl_union_map *
+getScheduleMap(isl_schedule *Schedule)
+{
+  isl_band_list *BandList = isl_schedule_get_band_forest(Schedule);
+  isl_union_map *ScheduleMap = getScheduleForBandList(BandList);
+  isl_band_list_free(BandList);
+  return ScheduleMap;
+}
+
+static int
+getSingleMap(__isl_take isl_map *map, void *user)
+{
+  isl_map **singleMap = (isl_map **) user;
+  *singleMap = map;
+
+  return 0;
+}
+
+static void
+apply_schedule_map_to_scop (scop_p scop, isl_union_map *schedule_map)
+{
+  int i;
+  poly_bb_p pbb;
+
+  FOR_EACH_VEC_ELT (poly_bb_p, scop->bbs, i, pbb)
+    {
+      isl_set *domain = isl_set_copy (pbb->domain);
+      isl_union_map *stmtBand;
+      isl_map *stmtSchedule;
+
+      stmtBand = isl_union_map_intersect_domain(isl_union_map_copy(schedule_map),
+						isl_union_set_from_set(domain));
+      isl_union_map_foreach_map(stmtBand, getSingleMap, &stmtSchedule);
+      isl_map_free(pbb->transformed);
+      pbb->transformed = stmtSchedule;
+      isl_union_map_free(stmtBand);
+    }
+}
+
+static const int CONSTANT_BOUND = 20;
+
+bool
+optimize_isl (scop_p scop)
+{
+
+  isl_schedule *schedule;
+  isl_union_set *domain;
+  isl_union_map *validity, *proximity, *dependences;
+  isl_union_map *schedule_map;
+
+  domain = scop_get_domains (scop);
+  dependences = scop_get_dependences (scop);
+  dependences = isl_union_map_gist_domain(dependences,
+					  isl_union_set_copy(domain));
+  dependences = isl_union_map_gist_range(dependences,
+					 isl_union_set_copy(domain));
+  validity = dependences;
+
+  proximity = isl_union_map_copy (validity);
+
+  isl_options_set_schedule_max_constant_term(scop->ctx, CONSTANT_BOUND);
+  isl_options_set_schedule_maximize_band_depth(scop->ctx, 1);
+  isl_options_set_schedule_fuse(scop->ctx, ISL_SCHEDULE_FUSE_MIN);
+  isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_CONTINUE);
+  schedule = isl_union_set_compute_schedule (domain, validity, proximity);
+  isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_ABORT);
+
+  if (!schedule)
+    return false;
+
+  schedule_map = getScheduleMap (schedule);
+
+  apply_schedule_map_to_scop (scop, schedule_map);
+
+  isl_schedule_free (schedule);
+  isl_union_map_free (schedule_map);
+
+  return true;
+}
+
+#endif
diff --git a/gcc/graphite-poly.c b/gcc/graphite-poly.c
index e3563a2..4869de6 100644
--- a/gcc/graphite-poly.c
+++ b/gcc/graphite-poly.c
@@ -250,6 +250,11 @@ apply_poly_transforms (scop_p scop)
 	transform_done |= scop_do_interchange (scop);
     }
 
+  // This pass needs to be run at the final stage, as it does not
+  // update the lst.
+  if (flag_loop_optimize_isl)
+    transform_done |= optimize_isl (scop);
+
   return transform_done;
 }
 
diff --git a/gcc/graphite-poly.h b/gcc/graphite-poly.h
index 0b95662..de1f06f 100644
--- a/gcc/graphite-poly.h
+++ b/gcc/graphite-poly.h
@@ -409,6 +409,7 @@ extern int scop_do_interchange (scop_p);
 extern int scop_do_strip_mine (scop_p, int);
 extern bool scop_do_block (scop_p);
 extern bool flatten_all_loops (scop_p);
+extern bool optimize_isl(scop_p);
 extern void pbb_number_of_iterations_at_time (poly_bb_p, graphite_dim_t, mpz_t);
 extern void debug_gmp_value (mpz_t);
 
@@ -1549,4 +1550,20 @@ isl_map *reverse_loop_at_level (poly_bb_p, int);
 isl_union_map *reverse_loop_for_pbbs (scop_p, VEC (poly_bb_p, heap) *, int);
 __isl_give isl_union_map *extend_schedule (__isl_take isl_union_map *);
 
+
+void
+compute_deps (scop_p scop, VEC (poly_bb_p, heap) *pbbs,
+	      isl_union_map **must_raw,
+	      isl_union_map **may_raw,
+	      isl_union_map **must_raw_no_source,
+	      isl_union_map **may_raw_no_source,
+	      isl_union_map **must_war,
+	      isl_union_map **may_war,
+	      isl_union_map **must_war_no_source,
+	      isl_union_map **may_war_no_source,
+	      isl_union_map **must_waw,
+	      isl_union_map **may_waw,
+	      isl_union_map **must_waw_no_source,
+	      isl_union_map **may_waw_no_source);
+
 #endif
diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
index c6304c4..bef68e7 100644
--- a/gcc/tree-ssa-loop.c
+++ b/gcc/tree-ssa-loop.c
@@ -265,7 +265,8 @@ gate_graphite_transforms (void)
       || flag_loop_interchange
       || flag_loop_strip_mine
       || flag_graphite_identity
-      || flag_loop_parallelize_all)
+      || flag_loop_parallelize_all
+      || flag_loop_optimize_isl)
     flag_graphite = 1;
 
   return flag_graphite != 0;
