Makefile.in (OBJS): Remove matrix-reorg.o.

2012-08-10  Richard Guenther  <rguenther@suse.de>

	* Makefile.in (OBJS): Remove matrix-reorg.o.
	(matrix-reorg.o): Remove dependence rule.
	(GTFILES): Remove matrix-reorg.c.
	* matrix-reorg.c: Remove.
	* passes.c (init_optimization_passes): Do not schedule
	pass_ipa_matrix_reorg.
	* tree-pass.h (pass_ipa_matrix_reorg): Remove.
	* common.opt (fipa-matrix-reorg): Stub out.
	* doc/invoke.texi (fipa-matrix-reorg): Remove documentation.

	* gcc.dg/matrix/*.c: Adjust and move ...
	* gcc.dg/torture/: ... here.
	* gcc.dg/matrix: Remove directory.

From-SVN: r190298

21 files changed, 46 insertions, 2514 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 914742e..0ba7d42 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,17 @@
 2012-08-10  Richard Guenther  <rguenther@suse.de>
 
+	* Makefile.in (OBJS): Remove matrix-reorg.o.
+	(matrix-reorg.o): Remove dependence rule.
+	(GTFILES): Remove matrix-reorg.c.
+	* matrix-reorg.c: Remove.
+	* passes.c (init_optimization_passes): Do not schedule
+	pass_ipa_matrix_reorg.
+	* tree-pass.h (pass_ipa_matrix_reorg): Remove.
+	* common.opt (fipa-matrix-reorg): Stub out.
+	* doc/invoke.texi (fipa-matrix-reorg): Remove documentation.
+
+2012-08-10  Richard Guenther  <rguenther@suse.de>
+
 	PR middle-end/54219
 	* fold-const.c (fold_ternary_loc): Do not reverse the mask
 	when canonicalizing it when folding VEC_PERM_EXPR.
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index bbd8cb1..ba0287f 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1301,7 +1301,6 @@ OBJS = \
 	lto-symtab.o \
 	lto-opts.o \
 	lto-compress.o \
-	matrix-reorg.o \
 	mcf.o \
 	mode-switching.o \
 	modulo-sched.o \
@@ -2893,13 +2892,6 @@ ipa-split.o : ipa-split.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TREE_H) $(TARGET_H) $(CGRAPH_H) $(IPA_PROP_H) $(TREE_FLOW_H) \
    $(TREE_PASS_H) $(FLAGS_H) $(DIAGNOSTIC_H) $(TREE_DUMP_H) \
    $(TREE_INLINE_H) $(PARAMS_H) $(GIMPLE_PRETTY_PRINT_H) ipa-inline.h
-matrix-reorg.o : matrix-reorg.c $(CONFIG_H) $(SYSTEM_H) coretypes.h  \
-   $(TM_H) $(TREE_H) $(RTL_H) $(TREE_INLINE_H) $(TREE_FLOW_H) \
-   tree-flow-inline.h langhooks.h $(HASHTAB_H) $(DIAGNOSTIC_CORE_H) $(FLAGS_H) $(GGC_H) \
-   debug.h $(TARGET_H) $(CGRAPH_H) $(DIAGNOSTIC_CORE_H) \
-   $(PARAMS_H) intl.h $(FUNCTION_H) $(BASIC_BLOCK_H) \
-   $(CFGLOOP_H) tree-iterator.h $(TREE_PASS_H) $(OPTS_H) $(TREE_DATA_REF_H) \
-   tree-ssa-sccvn.h
 ipa-inline.o : ipa-inline.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
    $(TREE_H) langhooks.h $(TREE_INLINE_H) $(FLAGS_H) $(CGRAPH_H) intl.h \
    $(DIAGNOSTIC_H) $(FIBHEAP_H) $(PARAMS_H) $(TREE_PASS_H) \
@@ -3657,7 +3649,7 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
   $(srcdir)/cselib.h $(srcdir)/basic-block.h  $(srcdir)/ipa-ref.h $(srcdir)/cgraph.h \
   $(srcdir)/reload.h $(srcdir)/caller-save.c $(srcdir)/symtab.c \
   $(srcdir)/alias.c $(srcdir)/bitmap.c $(srcdir)/cselib.c $(srcdir)/cgraph.c \
-  $(srcdir)/ipa-prop.c $(srcdir)/ipa-cp.c $(srcdir)/matrix-reorg.c \
+  $(srcdir)/ipa-prop.c $(srcdir)/ipa-cp.c \
   $(srcdir)/dbxout.c \
   $(srcdir)/dwarf2out.h \
   $(srcdir)/dwarf2asm.c \
diff --git a/gcc/common.opt b/gcc/common.opt
index f415f14..deb89e3 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1349,9 +1349,8 @@ Common Report Var(flag_ipa_reference) Init(0) Optimization
 Discover readonly and non addressable static variables
 
 fipa-matrix-reorg
-Common Report Var(flag_ipa_matrix_reorg) Optimization
-Perform matrix layout flattening and transposing based
-on profiling information.
+Common Ignore
+Does nothing. Preserved for backward compatibility.
 
 fipa-struct-reorg
 Common Ignore
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 379761c..f0d8a4a 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -367,7 +367,7 @@ Objective-C and Objective-C++ Dialects}.
 -fgcse-sm -fhoist-adjacent-loads -fif-conversion @gol
 -fif-conversion2 -findirect-inlining @gol
 -finline-functions -finline-functions-called-once -finline-limit=@var{n} @gol
--finline-small-functions -fipa-cp -fipa-cp-clone -fipa-matrix-reorg @gol
+-finline-small-functions -fipa-cp -fipa-cp-clone @gol
 -fipa-pta -fipa-profile -fipa-pure-const -fipa-reference @gol
 -fira-algorithm=@var{algorithm} @gol
 -fira-region=@var{region} @gol
@@ -7195,18 +7195,6 @@ it may significantly increase code size
 (see @option{--param ipcp-unit-growth=@var{value}}).
 This flag is enabled by default at @option{-O3}.
 
-@item -fipa-matrix-reorg
-@opindex fipa-matrix-reorg
-Perform matrix flattening and transposing.
-Matrix flattening tries to replace an @math{m}-dimensional matrix
-with its equivalent @math{n}-dimensional matrix, where @math{n < m}.
-This reduces the level of indirection needed for accessing the elements
-of the matrix. The second optimization is matrix transposing, which
-attempts to change the order of the matrix's dimensions in order to
-improve cache locality.
-Both optimizations need the @option{-fwhole-program} flag.
-Transposing is enabled only if profiling information is available.
-
 @item -ftree-sink
 @opindex ftree-sink
 Perform forward store motion  on trees.  This flag is
diff --git a/gcc/matrix-reorg.c b/gcc/matrix-reorg.c
deleted file mode 100644
index 6fe5613..0000000
--- a/gcc/matrix-reorg.c
+++ /dev/null
@@ -1,2384 +0,0 @@
-/* Matrix layout transformations.
-   Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
-   Contributed by Razya Ladelsky <razya@il.ibm.com>
-   Originally written by Revital Eres and Mustafa Hagog.
-
-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/>.  */
-
-/*
-   Matrix flattening optimization tries to replace a N-dimensional
-   matrix with its equivalent M-dimensional matrix, where M < N.
-   This first implementation focuses on global matrices defined dynamically.
-
-   When N==1, we actually flatten the whole matrix.
-   For instance consider a two-dimensional array a [dim1] [dim2].
-   The code for allocating space for it usually looks like:
-
-     a = (int **)  malloc(dim1 * sizeof(int *));
-     for (i=0; i<dim1; i++)
-        a[i] = (int *) malloc (dim2 * sizeof(int));
-
-   If the array "a" is found suitable for this optimization,
-   its allocation is replaced by:
-
-     a = (int *) malloc (dim1 * dim2 *sizeof(int));
-
-   and all the references to a[i][j] are replaced by a[i * dim2 + j].
-
-   The two main phases of the optimization are the analysis
-   and transformation.
-   The driver of the optimization is matrix_reorg ().
-
-
-
-   Analysis phase:
-   ===============
-
-   We'll number the dimensions outside-in, meaning the most external
-   is 0, then 1, and so on.
-   The analysis part of the optimization determines K, the escape
-   level of a N-dimensional matrix (K <= N), that allows flattening of
-   the external dimensions 0,1,..., K-1. Escape level 0 means that the
-   whole matrix escapes and no flattening is possible.
-
-   The analysis part is implemented in analyze_matrix_allocation_site()
-   and analyze_matrix_accesses().
-
-   Transformation phase:
-   =====================
-   In this phase we define the new flattened matrices that replace the
-   original matrices in the code.
-   Implemented in transform_allocation_sites(),
-   transform_access_sites().
-
-   Matrix Transposing
-   ==================
-   The idea of Matrix Transposing is organizing the matrix in a different
-   layout such that the dimensions are reordered.
-   This could produce better cache behavior in some cases.
-
-   For example, lets look at the matrix accesses in the following loop:
-
-   for (i=0; i<N; i++)
-    for (j=0; j<M; j++)
-     access to a[i][j]
-
-   This loop can produce good cache behavior because the elements of
-   the inner dimension are accessed sequentially.
-
-  However, if the accesses of the matrix were of the following form:
-
-  for (i=0; i<N; i++)
-   for (j=0; j<M; j++)
-     access to a[j][i]
-
-  In this loop we iterate the columns and not the rows.
-  Therefore, replacing the rows and columns
-  would have had an organization with better (cache) locality.
-  Replacing the dimensions of the matrix is called matrix transposing.
-
-  This  example, of course, could be enhanced to multiple dimensions matrices
-  as well.
-
-  Since a program could include all kind of accesses, there is a decision
-  mechanism, implemented in analyze_transpose(), which implements a
-  heuristic that tries to determine whether to transpose the matrix or not,
-  according to the form of the more dominant accesses.
-  This decision is transferred to the flattening mechanism, and whether
-  the matrix was transposed or not, the matrix is flattened (if possible).
-
-  This decision making is based on profiling information and loop information.
-  If profiling information is available, decision making mechanism will be
-  operated, otherwise the matrix will only be flattened (if possible).
-
-  Both optimizations are described in the paper "Matrix flattening and
-  transposing in GCC" which was presented in GCC summit 2006.
-  http://www.gccsummit.org/2006/2006-GCC-Summit-Proceedings.pdf.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "tree.h"
-#include "rtl.h"
-#include "tree-inline.h"
-#include "tree-flow.h"
-#include "tree-flow-inline.h"
-#include "langhooks.h"
-#include "hashtab.h"
-#include "flags.h"
-#include "ggc.h"
-#include "debug.h"
-#include "target.h"
-#include "cgraph.h"
-#include "diagnostic-core.h"
-#include "params.h"
-#include "intl.h"
-#include "function.h"
-#include "basic-block.h"
-#include "cfgloop.h"
-#include "tree-iterator.h"
-#include "tree-pass.h"
-#include "opts.h"
-#include "tree-data-ref.h"
-#include "tree-chrec.h"
-#include "tree-scalar-evolution.h"
-#include "tree-ssa-sccvn.h"
-
-/* We need to collect a lot of data from the original malloc,
-   particularly as the gimplifier has converted:
-
-   orig_var = (struct_type *) malloc (x * sizeof (struct_type *));
-
-   into
-
-   T3 = <constant> ;  ** <constant> is amount to malloc; precomputed **
-   T4 = malloc (T3);
-   T5 = (struct_type *) T4;
-   orig_var = T5;
-
-   The following struct fields allow us to collect all the necessary data from
-   the gimplified program.  The comments in the struct below are all based
-   on the gimple example above.  */
-
-struct malloc_call_data
-{
-  gimple call_stmt;		/* Tree for "T4 = malloc (T3);"                     */
-  tree size_var;		/* Var decl for T3.                                 */
-  tree malloc_size;		/* Tree for "<constant>", the rhs assigned to T3.   */
-};
-
-static tree can_calculate_expr_before_stmt (tree, sbitmap);
-static tree can_calculate_stmt_before_stmt (gimple, sbitmap);
-
-/* The front end of the compiler, when parsing statements of the form:
-
-   var = (type_cast) malloc (sizeof (type));
-
-   always converts this single statement into the following statements
-   (GIMPLE form):
-
-   T.1 = sizeof (type);
-   T.2 = malloc (T.1);
-   T.3 = (type_cast) T.2;
-   var = T.3;
-
-   Since we need to create new malloc statements and modify the original
-   statements somewhat, we need to find all four of the above statements.
-   Currently record_call_1 (called for building cgraph edges) finds and
-   records the statements containing the actual call to malloc, but we
-   need to find the rest of the variables/statements on our own.  That
-   is what the following function does.  */
-static void
-collect_data_for_malloc_call (gimple stmt, struct malloc_call_data *m_data)
-{
-  tree size_var = NULL;
-  tree malloc_fn_decl;
-  tree arg1;
-
-  gcc_assert (is_gimple_call (stmt));
-
-  malloc_fn_decl = gimple_call_fndecl (stmt);
-  if (malloc_fn_decl == NULL
-      || DECL_FUNCTION_CODE (malloc_fn_decl) != BUILT_IN_MALLOC)
-    return;
-
-  arg1 = gimple_call_arg (stmt, 0);
-  size_var = arg1;
-
-  m_data->call_stmt = stmt;
-  m_data->size_var = size_var;
-  if (TREE_CODE (size_var) != VAR_DECL)
-    m_data->malloc_size = size_var;
-  else
-    m_data->malloc_size = NULL_TREE;
-}
-
-/* Information about matrix access site.
-   For example: if an access site of matrix arr is arr[i][j]
-   the ACCESS_SITE_INFO structure will have the address
-   of arr as its stmt.  The INDEX_INFO will hold information about the
-   initial address and index of each dimension.  */
-struct access_site_info
-{
-  /* The statement (MEM_REF or POINTER_PLUS_EXPR).  */
-  gimple stmt;
-
-  /* In case of POINTER_PLUS_EXPR, what is the offset.  */
-  tree offset;
-
-  /* The index which created the offset.  */
-  tree index;
-
-  /* The indirection level of this statement.  */
-  int level;
-
-  /* TRUE for allocation site FALSE for access site.  */
-  bool is_alloc;
-
-  /* The function containing the access site.  */
-  tree function_decl;
-
-  /* This access is iterated in the inner most loop */
-  bool iterated_by_inner_most_loop_p;
-};
-
-typedef struct access_site_info *access_site_info_p;
-DEF_VEC_P (access_site_info_p);
-DEF_VEC_ALLOC_P (access_site_info_p, heap);
-
-/* Calls to free when flattening a matrix.  */
-
-struct free_info
-{
-  gimple stmt;
-  tree func;
-};
-
-/* Information about matrix to flatten.  */
-struct matrix_info
-{
-  /* Decl tree of this matrix.  */
-  tree decl;
-  /* Number of dimensions; number
-     of "*" in the type declaration.  */
-  int num_dims;
-
-  /* Minimum indirection level that escapes, 0 means that
-     the whole matrix escapes, k means that dimensions
-     0 to ACTUAL_DIM - k escapes.  */
-  int min_indirect_level_escape;
-
-  gimple min_indirect_level_escape_stmt;
-
-  /* Hold the allocation site for each level (dimension).
-     We can use NUM_DIMS as the upper bound and allocate the array
-     once with this number of elements and no need to use realloc and
-     MAX_MALLOCED_LEVEL.  */
-  gimple *malloc_for_level;
-
-  int max_malloced_level;
-
-  /* Is the matrix transposed.  */
-  bool is_transposed_p;
-
-  /* The location of the allocation sites (they must be in one
-     function).  */
-  tree allocation_function_decl;
-
-  /* The calls to free for each level of indirection.  */
-  struct free_info *free_stmts;
-
-  /* An array which holds for each dimension its size. where
-     dimension 0 is the outer most (one that contains all the others).
-   */
-  tree *dimension_size;
-
-  /* An array which holds for each dimension it's original size
-     (before transposing and flattening take place).  */
-  tree *dimension_size_orig;
-
-  /* An array which holds for each dimension the size of the type of
-     of elements accessed in that level (in bytes).  */
-  HOST_WIDE_INT *dimension_type_size;
-
-  int dimension_type_size_len;
-
-  /* An array collecting the count of accesses for each dimension.  */
-  gcov_type *dim_hot_level;
-
-  /* An array of the accesses to be flattened.
-     elements are of type "struct access_site_info *".  */
-  VEC (access_site_info_p, heap) * access_l;
-
-  /* A map of how the dimensions will be organized at the end of
-     the analyses.  */
-  int *dim_map;
-};
-
-/* In each phi node we want to record the indirection level we have when we
-   get to the phi node.  Usually we will have phi nodes with more than two
-   arguments, then we must assure that all of them get to the phi node with
-   the same indirection level, otherwise it's not safe to do the flattening.
-   So we record the information regarding the indirection level each time we
-   get to the phi node in this hash table.  */
-
-struct matrix_access_phi_node
-{
-  gimple phi;
-  int indirection_level;
-};
-
-/* We use this structure to find if the SSA variable is accessed inside the
-   tree and record the tree containing it.  */
-
-struct ssa_acc_in_tree
-{
-  /* The variable whose accesses in the tree we are looking for.  */
-  tree ssa_var;
-  /* The tree and code inside it the ssa_var is accessed, currently
-     it could be an MEM_REF or CALL_EXPR.  */
-  enum tree_code t_code;
-  tree t_tree;
-  /* The place in the containing tree.  */
-  tree *tp;
-  tree second_op;
-  bool var_found;
-};
-
-static void analyze_matrix_accesses (struct matrix_info *, tree, int, bool,
-				     sbitmap, bool);
-static int transform_allocation_sites (void **, void *);
-static int transform_access_sites (void **, void *);
-static int analyze_transpose (void **, void *);
-static int dump_matrix_reorg_analysis (void **, void *);
-
-static bool check_transpose_p;
-
-/* Hash function used for the phi nodes.  */
-
-static hashval_t
-mat_acc_phi_hash (const void *p)
-{
-  const struct matrix_access_phi_node *const ma_phi =
-    (const struct matrix_access_phi_node *) p;
-
-  return htab_hash_pointer (ma_phi->phi);
-}
-
-/* Equality means phi node pointers are the same.  */
-
-static int
-mat_acc_phi_eq (const void *p1, const void *p2)
-{
-  const struct matrix_access_phi_node *const phi1 =
-    (const struct matrix_access_phi_node *) p1;
-  const struct matrix_access_phi_node *const phi2 =
-    (const struct matrix_access_phi_node *) p2;
-
-  if (phi1->phi == phi2->phi)
-    return 1;
-
-  return 0;
-}
-
-/* Hold the PHI nodes we visit during the traversal for escaping
-   analysis.  */
-static htab_t htab_mat_acc_phi_nodes = NULL;
-
-/* This hash-table holds the information about the matrices we are
-   going to handle.  */
-static htab_t matrices_to_reorg = NULL;
-
-/* Return a hash for MTT, which is really a "matrix_info *".  */
-static hashval_t
-mtt_info_hash (const void *mtt)
-{
-  return htab_hash_pointer (((const struct matrix_info *) mtt)->decl);
-}
-
-/* Return true if MTT1 and MTT2 (which are really both of type
-   "matrix_info *") refer to the same decl.  */
-static int
-mtt_info_eq (const void *mtt1, const void *mtt2)
-{
-  const struct matrix_info *const i1 = (const struct matrix_info *) mtt1;
-  const struct matrix_info *const i2 = (const struct matrix_info *) mtt2;
-
-  if (i1->decl == i2->decl)
-    return true;
-
-  return false;
-}
-
-/* Return false if STMT may contain a vector expression.
-   In this situation, all matrices should not be flattened.  */
-static bool
-may_flatten_matrices_1 (gimple stmt)
-{
-  switch (gimple_code (stmt))
-    {
-    case GIMPLE_ASSIGN:
-    case GIMPLE_CALL:
-      if (!gimple_has_lhs (stmt))
-	return true;
-      if (TREE_CODE (TREE_TYPE (gimple_get_lhs (stmt))) == VECTOR_TYPE)
-	{
-	  if (dump_file)
-	    fprintf (dump_file,
-		     "Found vector type, don't flatten matrix\n");
-	  return false;
-	}
-      break;
-    case GIMPLE_ASM:
-      /* Asm code could contain vector operations.  */
-      return false;
-      break;
-    default:
-      break;
-    }
-  return true;
-}
-
-/* Return false if there are hand-written vectors in the program.
-   We disable the flattening in such a case.  */
-static bool
-may_flatten_matrices (struct cgraph_node *node)
-{
-  tree decl;
-  struct function *func;
-  basic_block bb;
-  gimple_stmt_iterator gsi;
-
-  decl = node->symbol.decl;
-  if (node->analyzed)
-    {
-      func = DECL_STRUCT_FUNCTION (decl);
-      FOR_EACH_BB_FN (bb, func)
-	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-	if (!may_flatten_matrices_1 (gsi_stmt (gsi)))
-	  return false;
-    }
-  return true;
-}
-
-/* Given a VAR_DECL, check its type to determine whether it is
-   a definition of a dynamic allocated matrix and therefore is
-   a suitable candidate for the matrix flattening optimization.
-   Return NULL if VAR_DECL is not such decl.  Otherwise, allocate
-   a MATRIX_INFO structure, fill it with the relevant information
-   and return a pointer to it.
-   TODO: handle also statically defined arrays.  */
-static struct matrix_info *
-analyze_matrix_decl (tree var_decl)
-{
-  struct matrix_info *m_node, tmpmi, *mi;
-  tree var_type;
-  int dim_num = 0;
-
-  gcc_assert (matrices_to_reorg);
-
-  if (TREE_CODE (var_decl) == PARM_DECL)
-    var_type = DECL_ARG_TYPE (var_decl);
-  else if (TREE_CODE (var_decl) == VAR_DECL)
-    var_type = TREE_TYPE (var_decl);
-  else
-    return NULL;
-
-  if (!POINTER_TYPE_P (var_type))
-    return NULL;
-
-  while (POINTER_TYPE_P (var_type))
-    {
-      var_type = TREE_TYPE (var_type);
-      dim_num++;
-    }
-
-  if (dim_num <= 1)
-    return NULL;
-
-  if (!COMPLETE_TYPE_P (var_type)
-      || TREE_CODE (TYPE_SIZE_UNIT (var_type)) != INTEGER_CST)
-    return NULL;
-
-  /* Check to see if this pointer is already in there.  */
-  tmpmi.decl = var_decl;
-  mi = (struct matrix_info *) htab_find (matrices_to_reorg, &tmpmi);
-
-  if (mi)
-    return NULL;
-
-  /* Record the matrix.  */
-
-  m_node = (struct matrix_info *) xcalloc (1, sizeof (struct matrix_info));
-  m_node->decl = var_decl;
-  m_node->num_dims = dim_num;
-  m_node->free_stmts
-    = (struct free_info *) xcalloc (dim_num, sizeof (struct free_info));
-
-  /* Init min_indirect_level_escape to -1 to indicate that no escape
-     analysis has been done yet.  */
-  m_node->min_indirect_level_escape = -1;
-  m_node->is_transposed_p = false;
-
-  return m_node;
-}
-
-/* Free matrix E.  */
-static void
-mat_free (void *e)
-{
-  struct matrix_info *mat = (struct matrix_info *) e;
-
-  if (!mat)
-    return;
-
-  free (mat->free_stmts);
-  free (mat->dim_hot_level);
-  free (mat->malloc_for_level);
-}
-
-/* Find all potential matrices.
-   TODO: currently we handle only multidimensional
-   dynamically allocated arrays.  */
-static void
-find_matrices_decl (void)
-{
-  struct matrix_info *tmp;
-  PTR *slot;
-  struct varpool_node *vnode;
-
-  gcc_assert (matrices_to_reorg);
-
-  /* For every global variable in the program:
-     Check to see if it's of a candidate type and record it.  */
-  FOR_EACH_DEFINED_VARIABLE (vnode)
-    {
-      tree var_decl = vnode->symbol.decl;
-
-      if (!var_decl || TREE_CODE (var_decl) != VAR_DECL)
-	continue;
-
-      if (matrices_to_reorg)
-	if ((tmp = analyze_matrix_decl (var_decl)))
-	  {
-	    if (!TREE_ADDRESSABLE (var_decl))
-	      {
-		slot = htab_find_slot (matrices_to_reorg, tmp, INSERT);
-		*slot = tmp;
-	      }
-	  }
-    }
-  return;
-}
-
-/* Mark that the matrix MI escapes at level L.  */
-static void
-mark_min_matrix_escape_level (struct matrix_info *mi, int l, gimple s)
-{
-  if (mi->min_indirect_level_escape == -1
-      || (mi->min_indirect_level_escape > l))
-    {
-      mi->min_indirect_level_escape = l;
-      mi->min_indirect_level_escape_stmt = s;
-    }
-}
-
-/* Find if the SSA variable is accessed inside the
-   tree and record the tree containing it.
-   The only relevant uses are the case of SSA_NAME, or SSA inside
-   MEM_REF, PLUS_EXPR, POINTER_PLUS_EXPR, MULT_EXPR.  */
-static void
-ssa_accessed_in_tree (tree t, struct ssa_acc_in_tree *a)
-{
-  a->t_code = TREE_CODE (t);
-  switch (a->t_code)
-    {
-    case SSA_NAME:
-      if (t == a->ssa_var)
-	a->var_found = true;
-      break;
-    case MEM_REF:
-      if (SSA_VAR_P (TREE_OPERAND (t, 0))
-	  && TREE_OPERAND (t, 0) == a->ssa_var)
-	a->var_found = true;
-      break;
-    default:
-      break;
-    }
-}
-
-/* Find if the SSA variable is accessed on the right hand side of
-   gimple call STMT. */
-
-static void
-ssa_accessed_in_call_rhs (gimple stmt, struct ssa_acc_in_tree *a)
-{
-  tree decl;
-  tree arg;
-  size_t i;
-
-  a->t_code = CALL_EXPR;
-  for (i = 0; i < gimple_call_num_args (stmt); i++)
-    {
-      arg = gimple_call_arg (stmt, i);
-      if (arg == a->ssa_var)
-	{
-	  a->var_found = true;
-	  decl = gimple_call_fndecl (stmt);
-	  a->t_tree = decl;
-	  break;
-	}
-    }
-}
-
-/* Find if the SSA variable is accessed on the right hand side of
-   gimple assign STMT. */
-
-static void
-ssa_accessed_in_assign_rhs (gimple stmt, struct ssa_acc_in_tree *a)
-{
-
-  a->t_code = gimple_assign_rhs_code (stmt);
-  switch (a->t_code)
-    {
-      tree op1, op2;
-
-    case SSA_NAME:
-    case MEM_REF:
-    CASE_CONVERT:
-    case VIEW_CONVERT_EXPR:
-      ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
-      break;
-    case POINTER_PLUS_EXPR:
-    case PLUS_EXPR:
-    case MULT_EXPR:
-      op1 = gimple_assign_rhs1 (stmt);
-      op2 = gimple_assign_rhs2 (stmt);
-
-      if (op1 == a->ssa_var)
-	{
-	  a->var_found = true;
-	  a->second_op = op2;
-	}
-      else if (op2 == a->ssa_var)
-	{
-	  a->var_found = true;
-	  a->second_op = op1;
-	}
-      break;
-    default:
-      break;
-    }
-}
-
-/* Record the access/allocation site information for matrix MI so we can
-   handle it later in transformation.  */
-static void
-record_access_alloc_site_info (struct matrix_info *mi, gimple stmt, tree offset,
-			       tree index, int level, bool is_alloc)
-{
-  struct access_site_info *acc_info;
-
-  if (!mi->access_l)
-    mi->access_l = VEC_alloc (access_site_info_p, heap, 100);
-
-  acc_info
-    = (struct access_site_info *)
-    xcalloc (1, sizeof (struct access_site_info));
-  acc_info->stmt = stmt;
-  acc_info->offset = offset;
-  acc_info->index = index;
-  acc_info->function_decl = current_function_decl;
-  acc_info->level = level;
-  acc_info->is_alloc = is_alloc;
-
-  VEC_safe_push (access_site_info_p, heap, mi->access_l, acc_info);
-
-}
-
-/* Record the malloc as the allocation site of the given LEVEL.  But
-   first we Make sure that all the size parameters passed to malloc in
-   all the allocation sites could be pre-calculated before the call to
-   the malloc of level 0 (the main malloc call).  */
-static void
-add_allocation_site (struct matrix_info *mi, gimple stmt, int level)
-{
-  struct malloc_call_data mcd;
-
-  /* Make sure that the allocation sites are in the same function.  */
-  if (!mi->allocation_function_decl)
-    mi->allocation_function_decl = current_function_decl;
-  else if (mi->allocation_function_decl != current_function_decl)
-    {
-      int min_malloc_level;
-
-      gcc_assert (mi->malloc_for_level);
-
-      /* Find the minimum malloc level that already has been seen;
-         we known its allocation function must be
-         MI->allocation_function_decl since it's different than
-         CURRENT_FUNCTION_DECL then the escaping level should be
-         MIN (LEVEL, MIN_MALLOC_LEVEL) - 1 , and the allocation function
-         must be set accordingly.  */
-      for (min_malloc_level = 0;
-	   min_malloc_level < mi->max_malloced_level
-	   && mi->malloc_for_level[min_malloc_level]; min_malloc_level++)
-	;
-      if (level < min_malloc_level)
-	{
-	  mi->allocation_function_decl = current_function_decl;
-	  mark_min_matrix_escape_level (mi, min_malloc_level, stmt);
-	}
-      else
-	{
-	  mark_min_matrix_escape_level (mi, level, stmt);
-	  /* cannot be that (level == min_malloc_level)
-	     we would have returned earlier.  */
-	  return;
-	}
-    }
-
-  /* Find the correct malloc information.  */
-  collect_data_for_malloc_call (stmt, &mcd);
-
-  /* We accept only calls to malloc function; we do not accept
-     calls like calloc and realloc.  */
-  if (!mi->malloc_for_level)
-    {
-      mi->malloc_for_level = XCNEWVEC (gimple, level + 1);
-      mi->max_malloced_level = level + 1;
-    }
-  else if (mi->max_malloced_level <= level)
-    {
-      mi->malloc_for_level
-	= XRESIZEVEC (gimple, mi->malloc_for_level, level + 1);
-
-      /* Zero the newly allocated items.  */
-      memset (&(mi->malloc_for_level[mi->max_malloced_level + 1]),
-	      0, (level - mi->max_malloced_level) * sizeof (tree));
-
-      mi->max_malloced_level = level + 1;
-    }
-  mi->malloc_for_level[level] = stmt;
-}
-
-/* Given an assignment statement STMT that we know that its
-   left-hand-side is the matrix MI variable, we traverse the immediate
-   uses backwards until we get to a malloc site.  We make sure that
-   there is one and only one malloc site that sets this variable.  When
-   we are performing the flattening we generate a new variable that
-   will hold the size for each dimension; each malloc that allocates a
-   dimension has the size parameter; we use that parameter to
-   initialize the dimension size variable so we can use it later in
-   the address calculations.  LEVEL is the dimension we're inspecting.
-   Return if STMT is related to an allocation site.  */
-
-static void
-analyze_matrix_allocation_site (struct matrix_info *mi, gimple stmt,
-				int level, sbitmap visited)
-{
-  if (gimple_assign_copy_p (stmt) || gimple_assign_cast_p (stmt))
-    {
-      tree rhs = gimple_assign_rhs1 (stmt);
-
-      if (TREE_CODE (rhs) == SSA_NAME)
-	{
-	  gimple def = SSA_NAME_DEF_STMT (rhs);
-
-	  analyze_matrix_allocation_site (mi, def, level, visited);
-	  return;
-	}
-      /* If we are back to the original matrix variable then we
-         are sure that this is analyzed as an access site.  */
-      else if (rhs == mi->decl)
-	return;
-    }
-  /* A result of call to malloc.  */
-  else if (is_gimple_call (stmt))
-    {
-      int call_flags = gimple_call_flags (stmt);
-
-      if (!(call_flags & ECF_MALLOC))
-	{
-	  mark_min_matrix_escape_level (mi, level, stmt);
-	  return;
-	}
-      else
-	{
-	  tree malloc_fn_decl;
-
-	  malloc_fn_decl = gimple_call_fndecl (stmt);
-	  if (malloc_fn_decl == NULL_TREE)
-	    {
-	      mark_min_matrix_escape_level (mi, level, stmt);
-	      return;
-	    }
-	  if (DECL_FUNCTION_CODE (malloc_fn_decl) != BUILT_IN_MALLOC)
-	    {
-	      if (dump_file)
-		fprintf (dump_file,
-			 "Matrix %s is an argument to function %s\n",
-			 get_name (mi->decl), get_name (malloc_fn_decl));
-	      mark_min_matrix_escape_level (mi, level, stmt);
-	      return;
-	    }
-	}
-      /* This is a call to malloc of level 'level'.
-	 mi->max_malloced_level-1 == level  means that we've
-	 seen a malloc statement of level 'level' before.
-	 If the statement is not the same one that we've
-	 seen before, then there's another malloc statement
-	 for the same level, which means that we need to mark
-	 it escaping.  */
-      if (mi->malloc_for_level
-	  && mi->max_malloced_level-1 == level
-	  && mi->malloc_for_level[level] != stmt)
-	{
-	  mark_min_matrix_escape_level (mi, level, stmt);
-	  return;
-	}
-      else
-	add_allocation_site (mi, stmt, level);
-      return;
-    }
-  /* Looks like we don't know what is happening in this
-     statement so be in the safe side and mark it as escaping.  */
-  mark_min_matrix_escape_level (mi, level, stmt);
-}
-
-/* The transposing decision making.
-   In order to calculate the profitability of transposing, we collect two
-   types of information regarding the accesses:
-   1. profiling information used to express the hotness of an access, that
-   is how often the matrix is accessed by this access site (count of the
-   access site).
-   2. which dimension in the access site is iterated by the inner
-   most loop containing this access.
-
-   The matrix will have a calculated value of weighted hotness for each
-   dimension.
-   Intuitively the hotness level of a dimension is a function of how
-   many times it was the most frequently accessed dimension in the
-   highly executed access sites of this matrix.
-
-   As computed by following equation:
-   m      n
-   __   __
-   \    \  dim_hot_level[i] +=
-   /_   /_
-   j     i
-                 acc[j]->dim[i]->iter_by_inner_loop * count(j)
-
-  Where n is the number of dims and m is the number of the matrix
-  access sites. acc[j]->dim[i]->iter_by_inner_loop is 1 if acc[j]
-  iterates over dim[i] in innermost loop, and is 0 otherwise.
-
-  The organization of the new matrix should be according to the
-  hotness of each dimension. The hotness of the dimension implies
-  the locality of the elements.*/
-static int
-analyze_transpose (void **slot, void *data ATTRIBUTE_UNUSED)
-{
-  struct matrix_info *mi = (struct matrix_info *) *slot;
-  int min_escape_l = mi->min_indirect_level_escape;
-  struct loop *loop;
-  affine_iv iv;
-  struct access_site_info *acc_info;
-  int i;
-
-  if (min_escape_l < 2 || !mi->access_l)
-    {
-      if (mi->access_l)
-	{
-	  FOR_EACH_VEC_ELT (access_site_info_p, mi->access_l, i, acc_info)
-	    free (acc_info);
-	  VEC_free (access_site_info_p, heap, mi->access_l);
-
-	}
-      return 1;
-    }
-  if (!mi->dim_hot_level)
-    mi->dim_hot_level =
-      (gcov_type *) xcalloc (min_escape_l, sizeof (gcov_type));
-
-
-  for (i = 0; VEC_iterate (access_site_info_p, mi->access_l, i, acc_info);
-       i++)
-    {
-      if (gimple_assign_rhs_code (acc_info->stmt) == POINTER_PLUS_EXPR
-	  && acc_info->level < min_escape_l)
-	{
-	  loop = loop_containing_stmt (acc_info->stmt);
-	  if (!loop || loop->inner)
-	    {
-	      free (acc_info);
-	      continue;
-	    }
-	  if (simple_iv (loop, loop, acc_info->offset, &iv, true))
-	    {
-	      if (iv.step != NULL)
-		{
-		  HOST_WIDE_INT istep;
-
-		  istep = int_cst_value (iv.step);
-		  if (istep != 0)
-		    {
-		      acc_info->iterated_by_inner_most_loop_p = 1;
-		      mi->dim_hot_level[acc_info->level] +=
-			gimple_bb (acc_info->stmt)->count;
-		    }
-
-		}
-	    }
-	}
-      free (acc_info);
-    }
-  VEC_free (access_site_info_p, heap, mi->access_l);
-
-  return 1;
-}
-
-/* Find the index which defines the OFFSET from base.
-   We walk from use to def until we find how the offset was defined.  */
-static tree
-get_index_from_offset (tree offset, gimple def_stmt)
-{
-  tree op1, op2, index;
-
-  if (gimple_code (def_stmt) == GIMPLE_PHI)
-    return NULL;
-  if ((gimple_assign_copy_p (def_stmt) || gimple_assign_cast_p (def_stmt))
-      && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
-    return get_index_from_offset (offset,
-				  SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_stmt)));
-  else if (is_gimple_assign (def_stmt)
-	   && gimple_assign_rhs_code (def_stmt) == MULT_EXPR)
-    {
-      op1 = gimple_assign_rhs1 (def_stmt);
-      op2 = gimple_assign_rhs2 (def_stmt);
-      if (TREE_CODE (op1) != INTEGER_CST && TREE_CODE (op2) != INTEGER_CST)
-	return NULL;
-      index = (TREE_CODE (op1) == INTEGER_CST) ? op2 : op1;
-      return index;
-    }
-  else
-    return NULL_TREE;
-}
-
-/* update MI->dimension_type_size[CURRENT_INDIRECT_LEVEL] with the size
-   of the type related to the SSA_VAR, or the type related to the
-   lhs of STMT, in the case that it is an MEM_REF.  */
-static void
-update_type_size (struct matrix_info *mi, gimple stmt, tree ssa_var,
-		  int current_indirect_level)
-{
-  tree lhs;
-  HOST_WIDE_INT type_size;
-
-  /* Update type according to the type of the MEM_REF expr.   */
-  if (is_gimple_assign (stmt)
-      && TREE_CODE (gimple_assign_lhs (stmt)) == MEM_REF)
-    {
-      lhs = gimple_assign_lhs (stmt);
-      gcc_assert (POINTER_TYPE_P
-		  (TREE_TYPE (TREE_OPERAND (lhs, 0))));
-      type_size =
-	int_size_in_bytes (TREE_TYPE
-			   (TREE_TYPE (TREE_OPERAND (lhs, 0))));
-    }
-  else
-    type_size = int_size_in_bytes (TREE_TYPE (ssa_var));
-
-  /* Record the size of elements accessed (as a whole)
-     in the current indirection level (dimension).  If the size of
-     elements is not known at compile time, mark it as escaping.  */
-  if (type_size <= 0)
-    mark_min_matrix_escape_level (mi, current_indirect_level, stmt);
-  else
-    {
-      int l = current_indirect_level;
-
-      if (!mi->dimension_type_size)
-	{
-	  mi->dimension_type_size
-	    = (HOST_WIDE_INT *) xcalloc (l + 1, sizeof (HOST_WIDE_INT));
-	  mi->dimension_type_size_len = l + 1;
-	}
-      else if (mi->dimension_type_size_len < l + 1)
-	{
-	  mi->dimension_type_size
-	    = (HOST_WIDE_INT *) xrealloc (mi->dimension_type_size,
-					  (l + 1) * sizeof (HOST_WIDE_INT));
-	  memset (&mi->dimension_type_size[mi->dimension_type_size_len],
-		  0, (l + 1 - mi->dimension_type_size_len)
-		  * sizeof (HOST_WIDE_INT));
-	  mi->dimension_type_size_len = l + 1;
-	}
-      /* Make sure all the accesses in the same level have the same size
-         of the type.  */
-      if (!mi->dimension_type_size[l])
-	mi->dimension_type_size[l] = type_size;
-      else if (mi->dimension_type_size[l] != type_size)
-	mark_min_matrix_escape_level (mi, l, stmt);
-    }
-}
-
-/* USE_STMT represents a GIMPLE_CALL, where one of the arguments is the
-   ssa var that we want to check because it came from some use of matrix
-   MI.  CURRENT_INDIRECT_LEVEL is the indirection level we reached so
-   far.  */
-
-static int
-analyze_accesses_for_call_stmt (struct matrix_info *mi, tree ssa_var,
-				gimple use_stmt, int current_indirect_level)
-{
-  tree fndecl = gimple_call_fndecl (use_stmt);
-
-  if (gimple_call_lhs (use_stmt))
-    {
-      tree lhs = gimple_call_lhs (use_stmt);
-      struct ssa_acc_in_tree lhs_acc, rhs_acc;
-
-      memset (&lhs_acc, 0, sizeof (lhs_acc));
-      memset (&rhs_acc, 0, sizeof (rhs_acc));
-
-      lhs_acc.ssa_var = ssa_var;
-      lhs_acc.t_code = ERROR_MARK;
-      ssa_accessed_in_tree (lhs, &lhs_acc);
-      rhs_acc.ssa_var = ssa_var;
-      rhs_acc.t_code = ERROR_MARK;
-      ssa_accessed_in_call_rhs (use_stmt, &rhs_acc);
-
-      /* The SSA must be either in the left side or in the right side,
-	 to understand what is happening.
-	 In case the SSA_NAME is found in both sides we should be escaping
-	 at this level because in this case we cannot calculate the
-	 address correctly.  */
-      if ((lhs_acc.var_found && rhs_acc.var_found
-	   && lhs_acc.t_code == MEM_REF)
-	  || (!rhs_acc.var_found && !lhs_acc.var_found))
-	{
-	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
-	  return current_indirect_level;
-	}
-      gcc_assert (!rhs_acc.var_found || !lhs_acc.var_found);
-
-      /* If we are storing to the matrix at some level, then mark it as
-	 escaping at that level.  */
-      if (lhs_acc.var_found)
-	{
-	  int l = current_indirect_level + 1;
-
-	  gcc_assert (lhs_acc.t_code == MEM_REF);
-	  mark_min_matrix_escape_level (mi, l, use_stmt);
-	  return current_indirect_level;
-	}
-    }
-
-  if (fndecl)
-    {
-      if (DECL_FUNCTION_CODE (fndecl) != BUILT_IN_FREE)
-	{
-	  if (dump_file)
-	    fprintf (dump_file,
-		     "Matrix %s: Function call %s, level %d escapes.\n",
-		     get_name (mi->decl), get_name (fndecl),
-		     current_indirect_level);
-	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
-	}
-      else if (mi->free_stmts[current_indirect_level].stmt != NULL
-	       && mi->free_stmts[current_indirect_level].stmt != use_stmt)
-	mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
-      else
-	{
-	  /*Record the free statements so we can delete them
-	     later. */
-	  int l = current_indirect_level;
-
-	  mi->free_stmts[l].stmt = use_stmt;
-	  mi->free_stmts[l].func = current_function_decl;
-	}
-    }
-  return current_indirect_level;
-}
-
-/* USE_STMT represents a phi node of the ssa var that we want to
-   check  because it came from some use of matrix
-   MI.
-   We check all the escaping levels that get to the PHI node
-   and make sure they are all the same escaping;
-   if not (which is rare) we let the escaping level be the
-   minimum level that gets into that PHI because starting from
-   that level we cannot expect the behavior of the indirections.
-   CURRENT_INDIRECT_LEVEL is the indirection level we reached so far.  */
-
-static void
-analyze_accesses_for_phi_node (struct matrix_info *mi, gimple use_stmt,
-			       int current_indirect_level, sbitmap visited,
-			       bool record_accesses)
-{
-
-  struct matrix_access_phi_node tmp_maphi, *maphi, **pmaphi;
-
-  tmp_maphi.phi = use_stmt;
-  if ((maphi = (struct matrix_access_phi_node *)
-       htab_find (htab_mat_acc_phi_nodes, &tmp_maphi)))
-    {
-      if (maphi->indirection_level == current_indirect_level)
-	return;
-      else
-	{
-	  int level = MIN (maphi->indirection_level,
-			   current_indirect_level);
-	  size_t j;
-	  gimple stmt = NULL;
-
-	  maphi->indirection_level = level;
-	  for (j = 0; j < gimple_phi_num_args (use_stmt); j++)
-	    {
-	      tree def = PHI_ARG_DEF (use_stmt, j);
-
-	      if (gimple_code (SSA_NAME_DEF_STMT (def)) != GIMPLE_PHI)
-		stmt = SSA_NAME_DEF_STMT (def);
-	    }
-	  mark_min_matrix_escape_level (mi, level, stmt);
-	}
-      return;
-    }
-  maphi = (struct matrix_access_phi_node *)
-    xcalloc (1, sizeof (struct matrix_access_phi_node));
-  maphi->phi = use_stmt;
-  maphi->indirection_level = current_indirect_level;
-
-  /* Insert to hash table.  */
-  pmaphi = (struct matrix_access_phi_node **)
-    htab_find_slot (htab_mat_acc_phi_nodes, maphi, INSERT);
-  gcc_assert (pmaphi);
-  *pmaphi = maphi;
-
-  if (!TEST_BIT (visited, SSA_NAME_VERSION (PHI_RESULT (use_stmt))))
-    {
-      SET_BIT (visited, SSA_NAME_VERSION (PHI_RESULT (use_stmt)));
-      analyze_matrix_accesses (mi, PHI_RESULT (use_stmt),
-			       current_indirect_level, false, visited,
-			       record_accesses);
-      RESET_BIT (visited, SSA_NAME_VERSION (PHI_RESULT (use_stmt)));
-    }
-}
-
-/* USE_STMT represents an assign statement (the rhs or lhs include
-   the ssa var that we want to check  because it came from some use of matrix
-   MI.  CURRENT_INDIRECT_LEVEL is the indirection level we reached so far.  */
-
-static int
-analyze_accesses_for_assign_stmt (struct matrix_info *mi, tree ssa_var,
-				  gimple use_stmt, int current_indirect_level,
-				  bool last_op, sbitmap visited,
-				  bool record_accesses)
-{
-  tree lhs = gimple_get_lhs (use_stmt);
-  struct ssa_acc_in_tree lhs_acc, rhs_acc;
-
-  memset (&lhs_acc, 0, sizeof (lhs_acc));
-  memset (&rhs_acc, 0, sizeof (rhs_acc));
-
-  lhs_acc.ssa_var = ssa_var;
-  lhs_acc.t_code = ERROR_MARK;
-  ssa_accessed_in_tree (lhs, &lhs_acc);
-  rhs_acc.ssa_var = ssa_var;
-  rhs_acc.t_code = ERROR_MARK;
-  ssa_accessed_in_assign_rhs (use_stmt, &rhs_acc);
-
-  /* The SSA must be either in the left side or in the right side,
-     to understand what is happening.
-     In case the SSA_NAME is found in both sides we should be escaping
-     at this level because in this case we cannot calculate the
-     address correctly.  */
-  if ((lhs_acc.var_found && rhs_acc.var_found
-       && lhs_acc.t_code == MEM_REF)
-      || (!rhs_acc.var_found && !lhs_acc.var_found))
-    {
-      mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
-      return current_indirect_level;
-    }
-  gcc_assert (!rhs_acc.var_found || !lhs_acc.var_found);
-
-  /* If we are storing to the matrix at some level, then mark it as
-     escaping at that level.  */
-  if (lhs_acc.var_found)
-    {
-      int l = current_indirect_level + 1;
-
-      gcc_assert (lhs_acc.t_code == MEM_REF);
-
-      if (!(gimple_assign_copy_p (use_stmt)
-	    || gimple_assign_cast_p (use_stmt))
-	  || (TREE_CODE (gimple_assign_rhs1 (use_stmt)) != SSA_NAME))
-	mark_min_matrix_escape_level (mi, l, use_stmt);
-      else
-	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (use_stmt));
-	  analyze_matrix_allocation_site (mi, def_stmt, l, visited);
-	  if (record_accesses)
-	    record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
-					   NULL_TREE, l, true);
-	  update_type_size (mi, use_stmt, NULL, l);
-	}
-      return current_indirect_level;
-    }
-  /* Now, check the right-hand-side, to see how the SSA variable
-     is used.  */
-  if (rhs_acc.var_found)
-    {
-      if (rhs_acc.t_code != MEM_REF
-	  && rhs_acc.t_code != POINTER_PLUS_EXPR && rhs_acc.t_code != SSA_NAME)
-	{
-	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
-	  return current_indirect_level;
-	}
-      /* If the access in the RHS has an indirection increase the
-         indirection level.  */
-      if (rhs_acc.t_code == MEM_REF)
-	{
-	  if (record_accesses)
-	    record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
-					   NULL_TREE,
-					   current_indirect_level, true);
-	  current_indirect_level += 1;
-	}
-      else if (rhs_acc.t_code == POINTER_PLUS_EXPR)
-	{
-	  gcc_assert (rhs_acc.second_op);
-	  if (last_op)
-	    /* Currently we support only one PLUS expression on the
-	       SSA_NAME that holds the base address of the current
-	       indirection level; to support more general case there
-	       is a need to hold a stack of expressions and regenerate
-	       the calculation later.  */
-	    mark_min_matrix_escape_level (mi, current_indirect_level,
-					  use_stmt);
-	  else
-	    {
-	      tree index;
-	      tree op1, op2;
-
-	      op1 = gimple_assign_rhs1 (use_stmt);
-	      op2 = gimple_assign_rhs2 (use_stmt);
-
-	      op2 = (op1 == ssa_var) ? op2 : op1;
-	      if (TREE_CODE (op2) == INTEGER_CST)
-		index =
-		  build_int_cst (TREE_TYPE (op1),
-				 TREE_INT_CST_LOW (op2) /
-				 int_size_in_bytes (TREE_TYPE (op1)));
-	      else
-		{
-		  index =
-		    get_index_from_offset (op2, SSA_NAME_DEF_STMT (op2));
-		  if (index == NULL_TREE)
-		    {
-		      mark_min_matrix_escape_level (mi,
-						    current_indirect_level,
-						    use_stmt);
-		      return current_indirect_level;
-		    }
-		}
-	      if (record_accesses)
-		record_access_alloc_site_info (mi, use_stmt, op2,
-					       index,
-					       current_indirect_level, false);
-	    }
-	}
-      /* If we are storing this level of indirection mark it as
-         escaping.  */
-      if (lhs_acc.t_code == MEM_REF || TREE_CODE (lhs) != SSA_NAME)
-	{
-	  int l = current_indirect_level;
-
-	  /* One exception is when we are storing to the matrix
-	     variable itself; this is the case of malloc, we must make
-	     sure that it's the one and only one call to malloc so
-	     we call analyze_matrix_allocation_site to check
-	     this out.  */
-	  if (TREE_CODE (lhs) != VAR_DECL || lhs != mi->decl)
-	    mark_min_matrix_escape_level (mi, current_indirect_level,
-					  use_stmt);
-	  else
-	    {
-	      /* Also update the escaping level.  */
-	      analyze_matrix_allocation_site (mi, use_stmt, l, visited);
-	      if (record_accesses)
-		record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
-					       NULL_TREE, l, true);
-	    }
-	}
-      else
-	{
-	  /* We are placing it in an SSA, follow that SSA.  */
-	  analyze_matrix_accesses (mi, lhs,
-				   current_indirect_level,
-				   rhs_acc.t_code == POINTER_PLUS_EXPR,
-				   visited, record_accesses);
-	}
-    }
-  return current_indirect_level;
-}
-
-/* Given a SSA_VAR (coming from a use statement of the matrix MI),
-   follow its uses and level of indirection and find out the minimum
-   indirection level it escapes in (the highest dimension) and the maximum
-   level it is accessed in (this will be the actual dimension of the
-   matrix).  The information is accumulated in MI.
-   We look at the immediate uses, if one escapes we finish; if not,
-   we make a recursive call for each one of the immediate uses of the
-   resulting SSA name.  */
-static void
-analyze_matrix_accesses (struct matrix_info *mi, tree ssa_var,
-			 int current_indirect_level, bool last_op,
-			 sbitmap visited, bool record_accesses)
-{
-  imm_use_iterator imm_iter;
-  use_operand_p use_p;
-
-  update_type_size (mi, SSA_NAME_DEF_STMT (ssa_var), ssa_var,
-		    current_indirect_level);
-
-  /* We don't go beyond the escaping level when we are performing the
-     flattening.  NOTE: we keep the last indirection level that doesn't
-     escape.  */
-  if (mi->min_indirect_level_escape > -1
-      && mi->min_indirect_level_escape <= current_indirect_level)
-    return;
-
-/* Now go over the uses of the SSA_NAME and check how it is used in
-   each one of them.  We are mainly looking for the pattern MEM_REF,
-   then a POINTER_PLUS_EXPR, then MEM_REF etc.  while in between there could
-   be any number of copies and casts.  */
-  gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
-
-  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, ssa_var)
-  {
-    gimple use_stmt = USE_STMT (use_p);
-    if (gimple_code (use_stmt) == GIMPLE_PHI)
-      /* We check all the escaping levels that get to the PHI node
-         and make sure they are all the same escaping;
-         if not (which is rare) we let the escaping level be the
-         minimum level that gets into that PHI because starting from
-         that level we cannot expect the behavior of the indirections.  */
-
-      analyze_accesses_for_phi_node (mi, use_stmt, current_indirect_level,
-				     visited, record_accesses);
-
-    else if (is_gimple_call (use_stmt))
-      analyze_accesses_for_call_stmt (mi, ssa_var, use_stmt,
-				      current_indirect_level);
-    else if (is_gimple_assign (use_stmt))
-      current_indirect_level =
-	analyze_accesses_for_assign_stmt (mi, ssa_var, use_stmt,
-					  current_indirect_level, last_op,
-					  visited, record_accesses);
-  }
-}
-
-typedef struct
-{
-  tree fn;
-  gimple stmt;
-} check_var_data;
-
-/* A walk_tree function to go over the VAR_DECL, PARM_DECL nodes of
-   the malloc size expression and check that those aren't changed
-   over the function.  */
-static tree
-check_var_notmodified_p (tree * tp, int *walk_subtrees, void *data)
-{
-  basic_block bb;
-  tree t = *tp;
-  check_var_data *callback_data = (check_var_data*) data;
-  tree fn = callback_data->fn;
-  gimple_stmt_iterator gsi;
-  gimple stmt;
-
-  if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
-    return NULL_TREE;
-
-  FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (fn))
-  {
-    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-      {
-	stmt = gsi_stmt (gsi);
-	if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
-	  continue;
-	if (gimple_get_lhs (stmt) == t)
-	  {
-	    callback_data->stmt = stmt;
-	    return t;
-	  }
-      }
-  }
-  *walk_subtrees = 1;
-  return NULL_TREE;
-}
-
-/* Go backwards in the use-def chains and find out the expression
-   represented by the possible SSA name in STMT, until it is composed
-   of only VAR_DECL, PARM_DECL and INT_CST.  In case of phi nodes
-   we make sure that all the arguments represent the same subexpression,
-   otherwise we fail.  */
-
-static tree
-can_calculate_stmt_before_stmt (gimple stmt, sbitmap visited)
-{
-  tree op1, op2, res;
-  enum tree_code code;
-
-  switch (gimple_code (stmt))
-    {
-    case GIMPLE_ASSIGN:
-      code = gimple_assign_rhs_code (stmt);
-      op1 = gimple_assign_rhs1 (stmt);
-
-      switch (code)
-	{
-	case POINTER_PLUS_EXPR:
-	case PLUS_EXPR:
-	case MINUS_EXPR:
-	case MULT_EXPR:
-
-	  op2 = gimple_assign_rhs2 (stmt);
-	  op1 = can_calculate_expr_before_stmt (op1, visited);
-	  if (!op1)
-	    return NULL_TREE;
-	  op2 = can_calculate_expr_before_stmt (op2, visited);
-	  if (op2)
-	    return fold_build2 (code, gimple_expr_type (stmt), op1, op2);
-	  return NULL_TREE;
-
-	CASE_CONVERT:
-	  res = can_calculate_expr_before_stmt (op1, visited);
-	  if (res != NULL_TREE)
-	    return build1 (code, gimple_expr_type (stmt), res);
-	  else
-	    return NULL_TREE;
-
-	default:
-	  if (gimple_assign_single_p (stmt))
-	    return can_calculate_expr_before_stmt (op1, visited);
-	  else
-	    return NULL_TREE;
-	}
-
-    case GIMPLE_PHI:
-      {
-	size_t j;
-
-	res = NULL_TREE;
-	/* Make sure all the arguments represent the same value.  */
-	for (j = 0; j < gimple_phi_num_args (stmt); j++)
-	  {
-	    tree new_res;
-	    tree def = PHI_ARG_DEF (stmt, j);
-
-	    new_res = can_calculate_expr_before_stmt (def, visited);
-	    if (res == NULL_TREE)
-	      res = new_res;
-	    else if (!new_res || !expressions_equal_p (res, new_res))
-	      return NULL_TREE;
-	  }
-	return res;
-      }
-
-    default:
-      return NULL_TREE;
-    }
-}
-
-/* Go backwards in the use-def chains and find out the expression
-   represented by the possible SSA name in EXPR, until it is composed
-   of only VAR_DECL, PARM_DECL and INT_CST.  In case of phi nodes
-   we make sure that all the arguments represent the same subexpression,
-   otherwise we fail.  */
-static tree
-can_calculate_expr_before_stmt (tree expr, sbitmap visited)
-{
-  gimple def_stmt;
-  tree res;
-
-  switch (TREE_CODE (expr))
-    {
-    case SSA_NAME:
-      /* Case of loop, we don't know to represent this expression.  */
-      if (TEST_BIT (visited, SSA_NAME_VERSION (expr)))
-	return NULL_TREE;
-
-      SET_BIT (visited, SSA_NAME_VERSION (expr));
-      def_stmt = SSA_NAME_DEF_STMT (expr);
-      res = can_calculate_stmt_before_stmt (def_stmt, visited);
-      RESET_BIT (visited, SSA_NAME_VERSION (expr));
-      return res;
-    case VAR_DECL:
-    case PARM_DECL:
-    case INTEGER_CST:
-      return expr;
-
-    default:
-      return NULL_TREE;
-    }
-}
-
-/* There should be only one allocation function for the dimensions
-   that don't escape. Here we check the allocation sites in this
-   function. We must make sure that all the dimensions are allocated
-   using malloc and that the malloc size parameter expression could be
-   pre-calculated before the call to the malloc of dimension 0.
-
-   Given a candidate matrix for flattening -- MI -- check if it's
-   appropriate for flattening -- we analyze the allocation
-   sites that we recorded in the previous analysis.  The result of the
-   analysis is a level of indirection (matrix dimension) in which the
-   flattening is safe.  We check the following conditions:
-   1. There is only one allocation site for each dimension.
-   2. The allocation sites of all the dimensions are in the same
-      function.
-      (The above two are being taken care of during the analysis when
-      we check the allocation site).
-   3. All the dimensions that we flatten are allocated at once; thus
-      the total size must be known before the allocation of the
-      dimension 0 (top level) -- we must make sure we represent the
-      size of the allocation as an expression of global parameters or
-      constants and that those doesn't change over the function.  */
-
-static int
-check_allocation_function (void **slot, void *data ATTRIBUTE_UNUSED)
-{
-  int level;
-  struct matrix_info *mi = (struct matrix_info *) *slot;
-  sbitmap visited;
-
-  if (!mi->malloc_for_level)
-    return 1;
-
-  visited = sbitmap_alloc (num_ssa_names);
-
-  /* Do nothing if the current function is not the allocation
-     function of MI.  */
-  if (mi->allocation_function_decl != current_function_decl
-      /* We aren't in the main allocation function yet.  */
-      || !mi->malloc_for_level[0])
-    return 1;
-
-  for (level = 1; level < mi->max_malloced_level; level++)
-    if (!mi->malloc_for_level[level])
-      break;
-
-  mark_min_matrix_escape_level (mi, level, NULL);
-
-  /* Check if the expression of the size passed to malloc could be
-     pre-calculated before the malloc of level 0.  */
-  for (level = 1; level < mi->min_indirect_level_escape; level++)
-    {
-      gimple call_stmt;
-      tree size;
-      struct malloc_call_data mcd = {NULL, NULL_TREE, NULL_TREE};
-
-      call_stmt = mi->malloc_for_level[level];
-
-      /* Find the correct malloc information.  */
-      collect_data_for_malloc_call (call_stmt, &mcd);
-
-      /* No need to check anticipation for constants.  */
-      if (TREE_CODE (mcd.size_var) == INTEGER_CST)
-	{
-	  if (!mi->dimension_size)
-	    {
-	      mi->dimension_size =
-		(tree *) xcalloc (mi->min_indirect_level_escape,
-				  sizeof (tree));
-	      mi->dimension_size_orig =
-		(tree *) xcalloc (mi->min_indirect_level_escape,
-				  sizeof (tree));
-	    }
-	  mi->dimension_size[level] = mcd.size_var;
-	  mi->dimension_size_orig[level] = mcd.size_var;
-	  continue;
-	}
-      /* ??? Here we should also add the way to calculate the size
-         expression not only know that it is anticipated.  */
-      sbitmap_zero (visited);
-      size = can_calculate_expr_before_stmt (mcd.size_var, visited);
-      if (size == NULL_TREE)
-	{
-	  mark_min_matrix_escape_level (mi, level, call_stmt);
-	  if (dump_file)
-	    fprintf (dump_file,
-		     "Matrix %s: Cannot calculate the size of allocation, escaping at level %d\n",
-		     get_name (mi->decl), level);
-	  break;
-	}
-      if (!mi->dimension_size)
-	{
-	  mi->dimension_size =
-	    (tree *) xcalloc (mi->min_indirect_level_escape, sizeof (tree));
-	  mi->dimension_size_orig =
-	    (tree *) xcalloc (mi->min_indirect_level_escape, sizeof (tree));
-	}
-      mi->dimension_size[level] = size;
-      mi->dimension_size_orig[level] = size;
-    }
-
-  /* We don't need those anymore.  */
-  for (level = mi->min_indirect_level_escape;
-       level < mi->max_malloced_level; level++)
-    mi->malloc_for_level[level] = NULL;
-  return 1;
-}
-
-/* Track all access and allocation sites.  */
-static void
-find_sites_in_func (bool record)
-{
-  sbitmap visited_stmts_1;
-
-  gimple_stmt_iterator gsi;
-  gimple stmt;
-  basic_block bb;
-  struct matrix_info tmpmi, *mi;
-
-  visited_stmts_1 = sbitmap_alloc (num_ssa_names);
-
-  FOR_EACH_BB (bb)
-  {
-    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-      {
-	tree lhs;
-
-	stmt = gsi_stmt (gsi);
-	lhs = gimple_get_lhs (stmt);
-	if (lhs != NULL_TREE
-	    && TREE_CODE (lhs) == VAR_DECL)
-	  {
-	    tmpmi.decl = lhs;
-	    if ((mi = (struct matrix_info *) htab_find (matrices_to_reorg,
-							&tmpmi)))
-	      {
-		sbitmap_zero (visited_stmts_1);
-		analyze_matrix_allocation_site (mi, stmt, 0, visited_stmts_1);
-	      }
-	  }
-	if (is_gimple_assign (stmt)
-	    && gimple_assign_single_p (stmt)
-	    && TREE_CODE (lhs) == SSA_NAME
-	    && TREE_CODE (gimple_assign_rhs1 (stmt)) == VAR_DECL)
-	  {
-	    tmpmi.decl = gimple_assign_rhs1 (stmt);
-	    if ((mi = (struct matrix_info *) htab_find (matrices_to_reorg,
-							&tmpmi)))
-	      {
-		sbitmap_zero (visited_stmts_1);
-		analyze_matrix_accesses (mi, lhs, 0,
-					 false, visited_stmts_1, record);
-	      }
-	  }
-      }
-  }
-  sbitmap_free (visited_stmts_1);
-}
-
-/* Traverse the use-def chains to see if there are matrices that
-   are passed through pointers and we cannot know how they are accessed.
-   For each SSA-name defined by a global variable of our interest,
-   we traverse the use-def chains of the SSA and follow the indirections,
-   and record in what level of indirection the use of the variable
-   escapes.  A use of a pointer escapes when it is passed to a function,
-   stored into memory or assigned (except in malloc and free calls).  */
-
-static void
-record_all_accesses_in_func (void)
-{
-  unsigned i;
-  sbitmap visited_stmts_1;
-
-  visited_stmts_1 = sbitmap_alloc (num_ssa_names);
-
-  for (i = 0; i < num_ssa_names; i++)
-    {
-      struct matrix_info tmpmi, *mi;
-      tree ssa_var = ssa_name (i);
-      tree rhs, lhs;
-
-      if (!ssa_var
-	  || !is_gimple_assign (SSA_NAME_DEF_STMT (ssa_var))
-	  || !gimple_assign_single_p (SSA_NAME_DEF_STMT (ssa_var)))
-	continue;
-      rhs = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ssa_var));
-      lhs = gimple_assign_lhs (SSA_NAME_DEF_STMT (ssa_var));
-      if (TREE_CODE (rhs) != VAR_DECL && TREE_CODE (lhs) != VAR_DECL)
-	continue;
-
-      /* If the RHS is a matrix that we want to analyze, follow the def-use
-         chain for this SSA_VAR and check for escapes or apply the
-         flattening.  */
-      tmpmi.decl = rhs;
-      if ((mi = (struct matrix_info *) htab_find (matrices_to_reorg, &tmpmi)))
-	{
-	  /* This variable will track the visited PHI nodes, so we can limit
-	     its size to the maximum number of SSA names.  */
-	  sbitmap_zero (visited_stmts_1);
-	  analyze_matrix_accesses (mi, ssa_var,
-				   0, false, visited_stmts_1, true);
-
-	}
-    }
-  sbitmap_free (visited_stmts_1);
-}
-
-/* Used when we want to convert the expression: RESULT = something *
-   ORIG to RESULT = something * NEW_VAL. If ORIG and NEW_VAL are power
-   of 2, shift operations can be done, else division and
-   multiplication.  */
-
-static tree
-compute_offset (HOST_WIDE_INT orig, HOST_WIDE_INT new_val, tree result)
-{
-
-  int x, y;
-  tree result1, ratio, log, orig_tree, new_tree;
-
-  x = exact_log2 (orig);
-  y = exact_log2 (new_val);
-
-  if (x != -1 && y != -1)
-    {
-      if (x == y)
-        return result;
-      else if (x > y)
-        {
-          log = build_int_cst (TREE_TYPE (result), x - y);
-          result1 =
-            fold_build2 (LSHIFT_EXPR, TREE_TYPE (result), result, log);
-          return result1;
-        }
-      log = build_int_cst (TREE_TYPE (result), y - x);
-      result1 = fold_build2 (RSHIFT_EXPR, TREE_TYPE (result), result, log);
-
-      return result1;
-    }
-  orig_tree = build_int_cst (TREE_TYPE (result), orig);
-  new_tree = build_int_cst (TREE_TYPE (result), new_val);
-  ratio = fold_build2 (TRUNC_DIV_EXPR, TREE_TYPE (result), result, orig_tree);
-  result1 = fold_build2 (MULT_EXPR, TREE_TYPE (result), ratio, new_tree);
-
-  return result1;
-}
-
-
-/* We know that we are allowed to perform matrix flattening (according to the
-   escape analysis), so we traverse the use-def chains of the SSA vars
-   defined by the global variables pointing to the matrices of our interest.
-   in each use of the SSA we calculate the offset from the base address
-   according to the following equation:
-
-     a[I1][I2]...[Ik] , where D1..Dk is the length of each dimension and the
-     escaping level is m <= k, and a' is the new allocated matrix,
-     will be translated to :
-
-       b[I(m+1)]...[Ik]
-
-       where
-       b = a' + I1*D2...*Dm + I2*D3...Dm + ... + Im
-                                                      */
-
-static int
-transform_access_sites (void **slot, void *data ATTRIBUTE_UNUSED)
-{
-  gimple_stmt_iterator gsi;
-  struct matrix_info *mi = (struct matrix_info *) *slot;
-  int min_escape_l = mi->min_indirect_level_escape;
-  struct access_site_info *acc_info;
-  enum tree_code code;
-  int i;
-
-  if (min_escape_l < 2 || !mi->access_l)
-    return 1;
-  for (i = 0; VEC_iterate (access_site_info_p, mi->access_l, i, acc_info);
-       i++)
-    {
-      /* This is possible because we collect the access sites before
-         we determine the final minimum indirection level.  */
-      if (acc_info->level >= min_escape_l)
-	{
-	  free (acc_info);
-	  continue;
-	}
-      if (acc_info->is_alloc)
-	{
-	  if (acc_info->level >= 0 && gimple_bb (acc_info->stmt))
-	    {
-	      gimple stmt = acc_info->stmt;
-	      tree lhs;
-
-	      gsi = gsi_for_stmt (stmt);
-	      gcc_assert (is_gimple_assign (acc_info->stmt));
-	      lhs = gimple_assign_lhs (acc_info->stmt);
-	      if (TREE_CODE (lhs) == SSA_NAME
-		  && acc_info->level < min_escape_l - 1)
-		{
-		  imm_use_iterator imm_iter;
-		  use_operand_p use_p;
-		  gimple use_stmt;
-
-		  FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs)
-		    FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
-		  {
-		    tree rhs, tmp;
-		    gimple new_stmt;
-
-		    gcc_assert (gimple_assign_rhs_code (acc_info->stmt)
-				== MEM_REF);
-		    /* Emit convert statement to convert to type of use.  */
-		    tmp = create_tmp_var (TREE_TYPE (lhs), "new");
-		    rhs = gimple_assign_rhs1 (acc_info->stmt);
-		    rhs = fold_convert (TREE_TYPE (tmp),
-					TREE_OPERAND (rhs, 0));
-		    new_stmt = gimple_build_assign (tmp, rhs);
-		    tmp = make_ssa_name (tmp, new_stmt);
-		    gimple_assign_set_lhs (new_stmt, tmp);
-		    gsi = gsi_for_stmt (acc_info->stmt);
-		    gsi_insert_after (&gsi, new_stmt, GSI_SAME_STMT);
-		    SET_USE (use_p, tmp);
-		  }
-		}
-	      if (acc_info->level < min_escape_l - 1)
-		gsi_remove (&gsi, true);
-	    }
-	  free (acc_info);
-	  continue;
-	}
-      code = gimple_assign_rhs_code (acc_info->stmt);
-      if (code == MEM_REF
-	  && acc_info->level < min_escape_l - 1)
-	{
-	  /* Replace the MEM_REF with NOP (cast) usually we are casting
-	     from "pointer to type" to "type".  */
-	  tree t =
-	    build1 (NOP_EXPR, TREE_TYPE (gimple_assign_rhs1 (acc_info->stmt)),
-		    TREE_OPERAND (gimple_assign_rhs1 (acc_info->stmt), 0));
-	  gimple_assign_set_rhs_code (acc_info->stmt, NOP_EXPR);
-	  gimple_assign_set_rhs1 (acc_info->stmt, t);
-	}
-      else if (code == POINTER_PLUS_EXPR
-	       && acc_info->level < (min_escape_l))
-	{
-	  imm_use_iterator imm_iter;
-	  use_operand_p use_p;
-
-	  tree offset;
-	  int k = acc_info->level;
-	  tree num_elements, total_elements;
-	  tree tmp1;
-	  tree d_size = mi->dimension_size[k];
-
-	  /* We already make sure in the analysis that the first operand
-	     is the base and the second is the offset.  */
-	  offset = acc_info->offset;
-	  if (mi->dim_map[k] == min_escape_l - 1)
-	    {
-	      if (!check_transpose_p || mi->is_transposed_p == false)
-		tmp1 = offset;
-	      else
-		{
-		  tree new_offset;
-
-		  new_offset =
-		    compute_offset (mi->dimension_type_size[min_escape_l],
-				    mi->dimension_type_size[k + 1], offset);
-
-		  total_elements = new_offset;
-		  if (new_offset != offset)
-		    {
-		      gsi = gsi_for_stmt (acc_info->stmt);
-		      tmp1 = force_gimple_operand_gsi (&gsi, total_elements,
-						       true, NULL,
-						       true, GSI_SAME_STMT);
-		    }
-		  else
-		    tmp1 = offset;
-		}
-	    }
-	  else
-	    {
-	      d_size = mi->dimension_size[mi->dim_map[k] + 1];
-	      num_elements =
-		fold_build2 (MULT_EXPR, sizetype, fold_convert (sizetype, acc_info->index),
-			    fold_convert (sizetype, d_size));
-	      gsi = gsi_for_stmt (acc_info->stmt);
-	      tmp1 = force_gimple_operand_gsi (&gsi, num_elements, true,
-					       NULL, true, GSI_SAME_STMT);
-	    }
-	  /* Replace the offset if needed.  */
-	  if (tmp1 != offset)
-	    {
-	      if (TREE_CODE (offset) == SSA_NAME)
-		{
-		  gimple use_stmt;
-
-		  FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, offset)
-		    FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
-		      if (use_stmt == acc_info->stmt)
-		        SET_USE (use_p, tmp1);
-		}
-	      else
-		{
-		  gcc_assert (TREE_CODE (offset) == INTEGER_CST);
-		  gimple_assign_set_rhs2 (acc_info->stmt, tmp1);
-		  update_stmt (acc_info->stmt);
-		}
-	    }
-	}
-      /* ??? meanwhile this happens because we record the same access
-         site more than once; we should be using a hash table to
-         avoid this and insert the STMT of the access site only
-         once.
-         else
-         gcc_unreachable (); */
-      free (acc_info);
-    }
-  VEC_free (access_site_info_p, heap, mi->access_l);
-
-  update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
-  verify_ssa (true);
-#endif
-  return 1;
-}
-
-/* Sort A array of counts. Arrange DIM_MAP to reflect the new order.  */
-
-static void
-sort_dim_hot_level (gcov_type * a, int *dim_map, int n)
-{
-  int i, j, tmp1;
-  gcov_type tmp;
-
-  for (i = 0; i < n - 1; i++)
-    {
-      for (j = 0; j < n - 1 - i; j++)
-	{
-	  if (a[j + 1] < a[j])
-	    {
-	      tmp = a[j];	/* swap a[j] and a[j+1]      */
-	      a[j] = a[j + 1];
-	      a[j + 1] = tmp;
-	      tmp1 = dim_map[j];
-	      dim_map[j] = dim_map[j + 1];
-	      dim_map[j + 1] = tmp1;
-	    }
-	}
-    }
-}
-
-/* Replace multiple mallocs (one for each dimension) to one malloc
-   with the size of DIM1*DIM2*...*DIMN*size_of_element
-   Make sure that we hold the size in the malloc site inside a
-   new global variable; this way we ensure that the size doesn't
-   change and it is accessible from all the other functions that
-   uses the matrix.  Also, the original calls to free are deleted,
-   and replaced by a new call to free the flattened matrix.  */
-
-static int
-transform_allocation_sites (void **slot, void *data ATTRIBUTE_UNUSED)
-{
-  int i;
-  struct matrix_info *mi;
-  tree type, oldfn, prev_dim_size;
-  gimple call_stmt_0, use_stmt;
-  struct cgraph_node *c_node;
-  struct cgraph_edge *e;
-  gimple_stmt_iterator gsi;
-  struct malloc_call_data mcd = {NULL, NULL_TREE, NULL_TREE};
-  HOST_WIDE_INT element_size;
-
-  imm_use_iterator imm_iter;
-  use_operand_p use_p;
-  tree old_size_0, tmp;
-  int min_escape_l;
-  int id;
-
-  mi = (struct matrix_info *) *slot;
-
-  min_escape_l = mi->min_indirect_level_escape;
-
-  if (!mi->malloc_for_level)
-    mi->min_indirect_level_escape = 0;
-
-  if (mi->min_indirect_level_escape < 2)
-    return 1;
-
-  mi->dim_map = (int *) xcalloc (mi->min_indirect_level_escape, sizeof (int));
-  for (i = 0; i < mi->min_indirect_level_escape; i++)
-    mi->dim_map[i] = i;
-  if (check_transpose_p)
-    {
-      int i;
-
-      if (dump_file)
-	{
-	  fprintf (dump_file, "Matrix %s:\n", get_name (mi->decl));
-	  for (i = 0; i < min_escape_l; i++)
-	    {
-	      fprintf (dump_file, "dim %d before sort ", i);
-	      if (mi->dim_hot_level)
-		fprintf (dump_file,
-			 "count is  " HOST_WIDEST_INT_PRINT_DEC "  \n",
-			 mi->dim_hot_level[i]);
-	    }
-	}
-      sort_dim_hot_level (mi->dim_hot_level, mi->dim_map,
-			  mi->min_indirect_level_escape);
-      if (dump_file)
-	for (i = 0; i < min_escape_l; i++)
-	  {
-	    fprintf (dump_file, "dim %d after sort\n", i);
-	    if (mi->dim_hot_level)
-	      fprintf (dump_file, "count is  " HOST_WIDE_INT_PRINT_DEC
-		       "  \n", (HOST_WIDE_INT) mi->dim_hot_level[i]);
-	  }
-      for (i = 0; i < mi->min_indirect_level_escape; i++)
-	{
-	  if (dump_file)
-	    fprintf (dump_file, "dim_map[%d] after sort %d\n", i,
-		     mi->dim_map[i]);
-	  if (mi->dim_map[i] != i)
-	    {
-	      if (dump_file)
-		fprintf (dump_file,
-			 "Transposed dimensions: dim %d is now dim %d\n",
-			 mi->dim_map[i], i);
-	      mi->is_transposed_p = true;
-	    }
-	}
-    }
-  else
-    {
-      for (i = 0; i < mi->min_indirect_level_escape; i++)
-	mi->dim_map[i] = i;
-    }
-  /* Call statement of allocation site of level 0.  */
-  call_stmt_0 = mi->malloc_for_level[0];
-
-  /* Finds the correct malloc information.  */
-  collect_data_for_malloc_call (call_stmt_0, &mcd);
-
-  mi->dimension_size[0] = mcd.size_var;
-  mi->dimension_size_orig[0] = mcd.size_var;
-  /* Make sure that the variables in the size expression for
-     all the dimensions (above level 0) aren't modified in
-     the allocation function.  */
-  for (i = 1; i < mi->min_indirect_level_escape; i++)
-    {
-      tree t;
-      check_var_data data;
-
-      /* mi->dimension_size must contain the expression of the size calculated
-         in check_allocation_function.  */
-      gcc_assert (mi->dimension_size[i]);
-
-      data.fn = mi->allocation_function_decl;
-      data.stmt = NULL;
-      t = walk_tree_without_duplicates (&(mi->dimension_size[i]),
-					check_var_notmodified_p,
-					&data);
-      if (t != NULL_TREE)
-	{
-	  mark_min_matrix_escape_level (mi, i, data.stmt);
-	  break;
-	}
-    }
-
-  if (mi->min_indirect_level_escape < 2)
-    return 1;
-
-  /* Since we should make sure that the size expression is available
-     before the call to malloc of level 0.  */
-  gsi = gsi_for_stmt (call_stmt_0);
-
-  /* Find out the size of each dimension by looking at the malloc
-     sites and create a global variable to hold it.
-     We add the assignment to the global before the malloc of level 0.  */
-
-  /* To be able to produce gimple temporaries.  */
-  oldfn = current_function_decl;
-  current_function_decl = mi->allocation_function_decl;
-  push_cfun (DECL_STRUCT_FUNCTION (mi->allocation_function_decl));
-
-  /* Set the dimension sizes as follows:
-     DIM_SIZE[i] = DIM_SIZE[n] * ... * DIM_SIZE[i]
-     where n is the maximum non escaping level.  */
-  element_size = mi->dimension_type_size[mi->min_indirect_level_escape];
-  prev_dim_size = NULL_TREE;
-
-  for (i = mi->min_indirect_level_escape - 1; i >= 0; i--)
-    {
-      tree dim_size, dim_var;
-      gimple stmt;
-      tree d_type_size;
-
-      /* Now put the size expression in a global variable and initialize it to
-         the size expression before the malloc of level 0.  */
-      dim_var =
-	add_new_static_var (TREE_TYPE
-			    (mi->dimension_size_orig[mi->dim_map[i]]));
-      type = TREE_TYPE (mi->dimension_size_orig[mi->dim_map[i]]);
-
-      /* DIM_SIZE = MALLOC_SIZE_PARAM / TYPE_SIZE.  */
-      /* Find which dim ID becomes dim I.  */
-      for (id = 0; id < mi->min_indirect_level_escape; id++)
-	if (mi->dim_map[id] == i)
-	  break;
-       d_type_size =
-        build_int_cst (type, mi->dimension_type_size[id + 1]);
-      if (!prev_dim_size)
-	prev_dim_size = build_int_cst (type, element_size);
-      if (!check_transpose_p && i == mi->min_indirect_level_escape - 1)
-	{
-	  dim_size = mi->dimension_size_orig[id];
-	}
-      else
-	{
-	  dim_size =
-	    fold_build2 (TRUNC_DIV_EXPR, type, mi->dimension_size_orig[id],
-			 d_type_size);
-
-	  dim_size = fold_build2 (MULT_EXPR, type, dim_size, prev_dim_size);
-	}
-      dim_size = force_gimple_operand_gsi (&gsi, dim_size, true, NULL,
-					   true, GSI_SAME_STMT);
-      /* GLOBAL_HOLDING_THE_SIZE = DIM_SIZE.  */
-      stmt = gimple_build_assign (dim_var, dim_size);
-      gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
-
-      prev_dim_size = mi->dimension_size[i] = dim_var;
-    }
-  update_ssa (TODO_update_ssa);
-  /* Replace the malloc size argument in the malloc of level 0 to be
-     the size of all the dimensions.  */
-  c_node = cgraph_get_node (mi->allocation_function_decl);
-  gcc_checking_assert (c_node);
-  old_size_0 = gimple_call_arg (call_stmt_0, 0);
-  tmp = force_gimple_operand_gsi (&gsi, mi->dimension_size[0], true,
-				  NULL, true, GSI_SAME_STMT);
-  if (TREE_CODE (old_size_0) == SSA_NAME)
-    {
-      FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, old_size_0)
-	FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
-	if (use_stmt == call_stmt_0)
-	SET_USE (use_p, tmp);
-    }
-  /* When deleting the calls to malloc we need also to remove the edge from
-     the call graph to keep it consistent.  Notice that cgraph_edge may
-     create a new node in the call graph if there is no node for the given
-     declaration; this shouldn't be the case but currently there is no way to
-     check this outside of "cgraph.c".  */
-  for (i = 1; i < mi->min_indirect_level_escape; i++)
-    {
-      gimple_stmt_iterator gsi;
-
-      gimple call_stmt = mi->malloc_for_level[i];
-      gcc_assert (is_gimple_call (call_stmt));
-      e = cgraph_edge (c_node, call_stmt);
-      gcc_assert (e);
-      cgraph_remove_edge (e);
-      gsi = gsi_for_stmt (call_stmt);
-      /* Remove the call stmt.  */
-      gsi_remove (&gsi, true);
-      /* Remove the assignment of the allocated area.  */
-      FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
-			     gimple_call_lhs (call_stmt))
-      {
-	gsi = gsi_for_stmt (use_stmt);
-	gsi_remove (&gsi, true);
-      }
-    }
-  update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
-  verify_ssa (true);
-#endif
-  /* Delete the calls to free.  */
-  for (i = 1; i < mi->min_indirect_level_escape; i++)
-    {
-      gimple_stmt_iterator gsi;
-
-      /* ??? wonder why this case is possible but we failed on it once.  */
-      if (!mi->free_stmts[i].stmt)
-	continue;
-
-      c_node = cgraph_get_node (mi->free_stmts[i].func);
-      gcc_checking_assert (c_node);
-      gcc_assert (is_gimple_call (mi->free_stmts[i].stmt));
-      e = cgraph_edge (c_node, mi->free_stmts[i].stmt);
-      gcc_assert (e);
-      cgraph_remove_edge (e);
-      current_function_decl = mi->free_stmts[i].func;
-      set_cfun (DECL_STRUCT_FUNCTION (mi->free_stmts[i].func));
-      gsi = gsi_for_stmt (mi->free_stmts[i].stmt);
-      gsi_remove (&gsi, true);
-    }
-  /* Return to the previous situation.  */
-  current_function_decl = oldfn;
-  pop_cfun ();
-  return 1;
-
-}
-
-
-/* Print out the results of the escape analysis.  */
-static int
-dump_matrix_reorg_analysis (void **slot, void *data ATTRIBUTE_UNUSED)
-{
-  struct matrix_info *mi = (struct matrix_info *) *slot;
-
-  if (!dump_file)
-    return 1;
-  fprintf (dump_file, "Matrix \"%s\"; Escaping Level: %d, Num Dims: %d,",
-	   get_name (mi->decl), mi->min_indirect_level_escape, mi->num_dims);
-  fprintf (dump_file, " Malloc Dims: %d, ", mi->max_malloced_level);
-  fprintf (dump_file, "\n");
-  if (mi->min_indirect_level_escape >= 2)
-    fprintf (dump_file, "Flattened %d dimensions \n",
-	     mi->min_indirect_level_escape);
-  return 1;
-}
-
-/* Perform matrix flattening.  */
-
-static unsigned int
-matrix_reorg (void)
-{
-  struct cgraph_node *node;
-
-  if (profile_info)
-    check_transpose_p = true;
-  else
-    check_transpose_p = false;
-  /* If there are hand written vectors, we skip this optimization.  */
-  FOR_EACH_FUNCTION (node)
-    if (!may_flatten_matrices (node))
-      return 0;
-  matrices_to_reorg = htab_create (37, mtt_info_hash, mtt_info_eq, mat_free);
-  /* Find and record all potential matrices in the program.  */
-  find_matrices_decl ();
-  /* Analyze the accesses of the matrices (escaping analysis).  */
-  FOR_EACH_DEFINED_FUNCTION (node)
-    {
-      tree temp_fn;
-
-      temp_fn = current_function_decl;
-      current_function_decl = node->symbol.decl;
-      push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
-      bitmap_obstack_initialize (NULL);
-      gimple_register_cfg_hooks ();
-
-      if (!gimple_in_ssa_p (cfun))
-	{
-	  free_dominance_info (CDI_DOMINATORS);
-	  free_dominance_info (CDI_POST_DOMINATORS);
-	  pop_cfun ();
-	  current_function_decl = temp_fn;
-	  bitmap_obstack_release (NULL);
-
-	  return 0;
-	}
-
-#ifdef ENABLE_CHECKING
-      verify_flow_info ();
-#endif
-
-      if (!matrices_to_reorg)
-	{
-	  free_dominance_info (CDI_DOMINATORS);
-	  free_dominance_info (CDI_POST_DOMINATORS);
-	  pop_cfun ();
-	  current_function_decl = temp_fn;
-	  bitmap_obstack_release (NULL);
-
-	  return 0;
-	}
-
-      /* Create htap for phi nodes.  */
-      htab_mat_acc_phi_nodes = htab_create (37, mat_acc_phi_hash,
-					    mat_acc_phi_eq, free);
-      if (!check_transpose_p)
-	find_sites_in_func (false);
-      else
-	{
-	  find_sites_in_func (true);
-	  loop_optimizer_init (LOOPS_NORMAL);
-	  if (current_loops)
-	    scev_initialize ();
-	  htab_traverse (matrices_to_reorg, analyze_transpose, NULL);
-	  if (current_loops)
-	    {
-	      scev_finalize ();
-	      loop_optimizer_finalize ();
-	      current_loops = NULL;
-	    }
-	}
-      /* If the current function is the allocation function for any of
-	 the matrices we check its allocation and the escaping level.  */
-      htab_traverse (matrices_to_reorg, check_allocation_function, NULL);
-      free_dominance_info (CDI_DOMINATORS);
-      free_dominance_info (CDI_POST_DOMINATORS);
-      pop_cfun ();
-      current_function_decl = temp_fn;
-      bitmap_obstack_release (NULL);
-    }
-  htab_traverse (matrices_to_reorg, transform_allocation_sites, NULL);
-  /* Now transform the accesses.  */
-  FOR_EACH_DEFINED_FUNCTION (node)
-    {
-      /* Remember that allocation sites have been handled.  */
-      tree temp_fn;
-
-      temp_fn = current_function_decl;
-      current_function_decl = node->symbol.decl;
-      push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
-      bitmap_obstack_initialize (NULL);
-      gimple_register_cfg_hooks ();
-      record_all_accesses_in_func ();
-      htab_traverse (matrices_to_reorg, transform_access_sites, NULL);
-      cgraph_rebuild_references ();
-      free_dominance_info (CDI_DOMINATORS);
-      free_dominance_info (CDI_POST_DOMINATORS);
-      pop_cfun ();
-      current_function_decl = temp_fn;
-      bitmap_obstack_release (NULL);
-    }
-  htab_traverse (matrices_to_reorg, dump_matrix_reorg_analysis, NULL);
-
-  current_function_decl = NULL;
-  set_cfun (NULL);
-  matrices_to_reorg = NULL;
-  return 0;
-}
-
-
-/* The condition for matrix flattening to be performed.  */
-static bool
-gate_matrix_reorg (void)
-{
-  return flag_ipa_matrix_reorg && flag_whole_program;
-}
-
-struct simple_ipa_opt_pass pass_ipa_matrix_reorg =
-{
- {
-  SIMPLE_IPA_PASS,
-  "matrix-reorg",		/* name */
-  gate_matrix_reorg,		/* gate */
-  matrix_reorg,			/* execute */
-  NULL,				/* sub */
-  NULL,				/* next */
-  0,				/* static_pass_number */
-  TV_NONE,			/* tv_id */
-  0,				/* properties_required */
-  0,				/* properties_provided */
-  0,				/* properties_destroyed */
-  0,				/* todo_flags_start */
-  TODO_dump_symtab      	/* todo_flags_finish */
- }
-};
diff --git a/gcc/passes.c b/gcc/passes.c
index 31e1f25..876aa5c 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -1330,7 +1330,6 @@ init_optimization_passes (void)
       NEXT_PASS (pass_feedback_split_functions);
     }
   NEXT_PASS (pass_ipa_increase_alignment);
-  NEXT_PASS (pass_ipa_matrix_reorg);
   NEXT_PASS (pass_ipa_tm);
   NEXT_PASS (pass_ipa_lower_emutls);
   *p = NULL;
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index bc85735..0602c04 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,5 +1,11 @@
 2012-08-10  Richard Guenther  <rguenther@suse.de>
 
+	* gcc.dg/matrix/*.c: Adjust and move ...
+	* gcc.dg/torture/: ... here.
+	* gcc.dg/matrix: Remove directory.
+
+2012-08-10  Richard Guenther  <rguenther@suse.de>
+
 	PR middle-end/54219
 	* gcc.dg/torture/vector-shuffle1.c: New testcase.
 
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix.exp b/gcc/testsuite/gcc.dg/matrix/matrix.exp
deleted file mode 100644
index d2e1344..0000000
--- a/gcc/testsuite/gcc.dg/matrix/matrix.exp
+++ /dev/null
@@ -1,67 +0,0 @@
-#   Copyright (C) 2001, 2002, 2004, 2005, 2007, 2010, 2011
-#   Free Software Foundation, Inc.
-
-# This program 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
-# 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/>.
-
-# Test the functionality of programs compiled with profile-directed block
-# ordering using -fprofile-generate followed by -fbranch-use.
-load_lib gcc-dg.exp
-load_lib target-supports.exp
-
-set DEFAULT_MATCFLAGS "-O3 -fipa-matrix-reorg -fdump-ipa-matrix-reorg -fwhole-program -fno-tree-fre"
-
-# Initialize `dg'.
-dg-init
-
-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/matrix-\[1-6\].\[cS\]]]  \
-        "" $DEFAULT_MATCFLAGS
-
-dg-final
-
-# Some targets don't support tree profiling.
-if { ![check_profiling_available "-fprofile-generate"] } {
-    return
-}
-
-# The procedures in profopt.exp need these parameters.
-set tool gcc
-set prof_ext "gcda"
-
-if $tracelevel then {
-    strace $tracelevel
-}
-
-# Load support procs.
-load_lib profopt.exp
-
-# Save and override the default list defined in profopt.exp.
-set matrix_save_profopt_options $PROFOPT_OPTIONS
-set PROFOPT_OPTIONS [list {}]
-
-# These are globals used by profopt-execute.  The first is options
-# needed to generate profile data, the second is options to use the
-# profile data.
-set profile_option "-fprofile-generate -O3 -fno-tree-fre"
-set feedback_option "-fprofile-use -fipa-matrix-reorg -fdump-ipa-matrix-reorg -O3 -fwhole-program -fno-tree-fre"
-
-foreach src [lsort [glob -nocomplain $srcdir/$subdir/transpose-*.c]] {
-    # If we're only testing specific files and this isn't one of them, skip it.
-    if ![runtest_file_p $runtests $src] then {
-        continue
-    }
-    profopt-execute $src
-}
-
-set PROFOPT_OPTIONS $matrix_save_profopt_options
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-1.c b/gcc/testsuite/gcc.dg/torture/matrix-1.c
index 12df172..1b88599 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-1.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-1.c
@@ -1,5 +1,5 @@
-/* { dg-do compile } */
 /* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -88,5 +88,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-2.c b/gcc/testsuite/gcc.dg/torture/matrix-2.c
index 318faa5..5013671 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-2.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-2.c
@@ -1,5 +1,5 @@
-/* { dg-do compile } */
 /* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
 
 
 #include <stdio.h>
@@ -111,5 +111,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-3.c b/gcc/testsuite/gcc.dg/torture/matrix-3.c
index 28a5a16..c646899 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-3.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-3.c
@@ -95,5 +95,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-4.c b/gcc/testsuite/gcc.dg/torture/matrix-4.c
index d741b46..586443c 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-4.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-4.c
@@ -93,5 +93,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened" 0 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-5.c b/gcc/testsuite/gcc.dg/torture/matrix-5.c
index 1398c5b..9b17567 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-5.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-5.c
@@ -1,5 +1,5 @@
-/* { dg-do compile } */
 /* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
 
 
 #include <stdio.h>
@@ -94,5 +94,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened" 0 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/matrix-6.c b/gcc/testsuite/gcc.dg/torture/matrix-6.c
index 536afb5..cad63dd 100644
--- a/gcc/testsuite/gcc.dg/matrix/matrix-6.c
+++ b/gcc/testsuite/gcc.dg/torture/matrix-6.c
@@ -1,4 +1,5 @@
-/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
 
 
 #include <stdio.h>
@@ -40,7 +41,8 @@ main (int argc, char **argv)
     }
   for (i = 0; i < ARCHnodes; i++)
     for (j = 0; j < 3; j++)
-      free (vel[i][j]);
+      if (!(i == 1 && j == 0))
+	free (vel[i][j]);
 
   for (i = 0; i < ARCHnodes; i++)
     free (vel[i]);
@@ -93,5 +95,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-1.c b/gcc/testsuite/gcc.dg/torture/transpose-1.c
index 8969ecb..188f3b5 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-1.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-1.c
@@ -1,3 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -92,7 +95,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 3 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
-
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-2.c b/gcc/testsuite/gcc.dg/torture/transpose-2.c
index 5943781..bff6a3a 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-2.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-2.c
@@ -1,3 +1,5 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -90,6 +92,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-3.c b/gcc/testsuite/gcc.dg/torture/transpose-3.c
index 5defdb8..da7e887 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-3.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-3.c
@@ -1,3 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -96,6 +99,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 2 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-4.c b/gcc/testsuite/gcc.dg/torture/transpose-4.c
index f6eb465..5a96a51 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-4.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-4.c
@@ -1,3 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -95,6 +98,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 2 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-5.c b/gcc/testsuite/gcc.dg/torture/transpose-5.c
index 27e8476..049d7b0 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-5.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-5.c
@@ -1,3 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -91,6 +94,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/testsuite/gcc.dg/matrix/transpose-6.c b/gcc/testsuite/gcc.dg/torture/transpose-6.c
index f7c6a8a..9b3329b 100644
--- a/gcc/testsuite/gcc.dg/matrix/transpose-6.c
+++ b/gcc/testsuite/gcc.dg/torture/transpose-6.c
@@ -1,3 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-fwhole-program" } */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -91,6 +94,3 @@ mem_init (void)
 }
 
 /*--------------------------------------------------------------------------*/
-/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
-/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
-/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index 4be92f4..66319c7 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -372,7 +372,6 @@ extern struct simple_ipa_opt_pass pass_early_local_passes;
 extern struct ipa_opt_pass_d pass_ipa_whole_program_visibility;
 extern struct ipa_opt_pass_d pass_ipa_lto_gimple_out;
 extern struct simple_ipa_opt_pass pass_ipa_increase_alignment;
-extern struct simple_ipa_opt_pass pass_ipa_matrix_reorg;
 extern struct ipa_opt_pass_d pass_ipa_inline;
 extern struct simple_ipa_opt_pass pass_ipa_free_lang_data;
 extern struct simple_ipa_opt_pass pass_ipa_free_inline_summary;