RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Marek Polacek]

This patch implements a new pass, called laddress, which deals with
lowering ADDR_EXPR assignments.  Such lowering ought to help the
vectorizer, but it also could expose more CSE opportunities, maybe
help reassoc, etc.  It's only active when optimize != 0.

So e.g.
  _1 = (sizetype) i_9;
  _7 = _1 * 4;
  _4 = &b + _7;
instead of
  _4 = &b[i_9];

This triggered 14105 times during the regtest and 6392 times during
the bootstrap.

The fallout (at least on x86_64) is surprisingly small, i.e. none, just
gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
to a bug in the vectorizer.  Jakub has a patch and knows the details.
As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
(that was the motivation of this pass).

This doesn't introduce any kind of verification nor PROP_laddress.
Don't know if we want that, but hopefully it can be done as a follow-up
if we do.  Do we want to move some optimizations into this new pass, e.g.
from fwprop?

Thoughts?

Bootstrapped/regtested on x86_64-linux.

2015-07-03  Marek Polacek  <polacek@redhat.com>

	PR tree-optimization/66718
	* Makefile.in (OBJS): Add tree-ssa-laddress.o. 
	* passes.def: Schedule pass_laddress.
	* timevar.def (DEFTIMEVAR): Add TV_TREE_LADDRESS.
	* tree-pass.h (make_pass_laddress): Declare.
	* tree-ssa-laddress.c: New file.

	* gcc.dg/vect/vect-126.c: New test.

diff --git gcc/Makefile.in gcc/Makefile.in
index 89eda96..2574b98 100644
--- gcc/Makefile.in
+++ gcc/Makefile.in
@@ -1447,6 +1447,7 @@ OBJS = \
 	tree-ssa-dse.o \
 	tree-ssa-forwprop.o \
 	tree-ssa-ifcombine.o \
+	tree-ssa-laddress.o \
 	tree-ssa-live.o \
 	tree-ssa-loop-ch.o \
 	tree-ssa-loop-im.o \
diff --git gcc/passes.def gcc/passes.def
index 0d8356b..ac16e8a 100644
--- gcc/passes.def
+++ gcc/passes.def
@@ -214,6 +214,7 @@ along with GCC; see the file COPYING3.  If not see
       NEXT_PASS (pass_cse_sincos);
       NEXT_PASS (pass_optimize_bswap);
       NEXT_PASS (pass_split_crit_edges);
+      NEXT_PASS (pass_laddress);
       NEXT_PASS (pass_pre);
       NEXT_PASS (pass_sink_code);
       NEXT_PASS (pass_asan);
diff --git gcc/testsuite/gcc.dg/vect/vect-126.c gcc/testsuite/gcc.dg/vect/vect-126.c
index e69de29..66a5821 100644
--- gcc/testsuite/gcc.dg/vect/vect-126.c
+++ gcc/testsuite/gcc.dg/vect/vect-126.c
@@ -0,0 +1,64 @@
+/* PR tree-optimization/66718 */
+/* { dg-do compile } */
+/* { dg-additional-options "-mavx2" { target avx_runtime } } */
+
+int *a[1024], b[1024];
+struct S { int u, v, w, x; };
+struct S c[1024];
+int d[1024][10];
+
+void
+f0 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &b[0];
+}
+
+void
+f1 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    {
+      int *p = &b[0];
+      a[i] = p + i;
+    }
+}
+
+void
+f2 (int *p)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &p[i];
+}
+
+void
+f3 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &b[i];
+}
+
+void
+f4 (void)
+{
+  int *p = &c[0].v;
+  for (int i = 0; i < 1024; i++)
+    a[i] = &p[4 * i];
+}
+
+void
+f5 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &c[i].v;
+}
+
+void
+f6 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    for (unsigned int j = 0; j < 10; j++)
+      a[i] = &d[i][j];
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops in function" 7 "vect" { target vect_condition } } } */
diff --git gcc/timevar.def gcc/timevar.def
index efac4b7..fcc2fe0 100644
--- gcc/timevar.def
+++ gcc/timevar.def
@@ -275,6 +275,7 @@ DEFTIMEVAR (TV_GIMPLE_SLSR           , "straight-line strength reduction")
 DEFTIMEVAR (TV_VTABLE_VERIFICATION   , "vtable verification")
 DEFTIMEVAR (TV_TREE_UBSAN            , "tree ubsan")
 DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
+DEFTIMEVAR (TV_TREE_LADDRESS         , "address lowering")
 
 /* Everything else in rest_of_compilation not included above.  */
 DEFTIMEVAR (TV_EARLY_LOCAL	     , "early local passes")
diff --git gcc/tree-pass.h gcc/tree-pass.h
index 2808dad..c47b22e 100644
--- gcc/tree-pass.h
+++ gcc/tree-pass.h
@@ -393,6 +393,7 @@ extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
 extern unsigned int tail_merge_optimize (unsigned int);
 extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);
diff --git gcc/tree-ssa-laddress.c gcc/tree-ssa-laddress.c
index e69de29..3f69d7d 100644
--- gcc/tree-ssa-laddress.c
+++ gcc/tree-ssa-laddress.c
@@ -0,0 +1,137 @@
+/* Lower and optimize address expressions.
+   Copyright (C) 2015 Free Software Foundation, Inc.
+   Contributed by Marek Polacek <polacek@redhat.com>
+
+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"
+#include "system.h"
+#include "coretypes.h"
+#include "alias.h"
+#include "predict.h"
+#include "tm.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "symtab.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "fold-const.h"
+#include "gimple-expr.h"
+#include "gimple.h"
+#include "gimplify.h"
+#include "gimple-iterator.h"
+#include "gimplify-me.h"
+#include "tree-pass.h"
+
+
+namespace {
+
+const pass_data pass_data_laddress =
+{
+  GIMPLE_PASS, /* type */
+  "laddress", /* name */
+  OPTGROUP_NONE, /* optinfo_flags */
+  TV_TREE_LADDRESS, /* tv_id */
+  ( PROP_cfg | PROP_ssa ), /* properties_required */
+  0, /* properties_provided */
+  0, /* properties_destroyed */
+  0, /* todo_flags_start */
+  0, /* todo_flags_finish */
+};
+
+class pass_laddress : public gimple_opt_pass
+{
+public:
+  pass_laddress (gcc::context *ctxt)
+    : gimple_opt_pass (pass_data_laddress, ctxt)
+  {}
+
+  /* opt_pass methods: */
+  opt_pass * clone () { return new pass_laddress (m_ctxt); }
+  virtual bool gate (function *) { return optimize != 0; }
+  virtual unsigned int execute (function *);
+
+}; // class pass_laddress
+
+unsigned int
+pass_laddress::execute (function *fun)
+{
+  basic_block bb;
+
+  FOR_EACH_BB_FN (bb, fun)
+    {
+      for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
+	{
+	  gimple stmt = gsi_stmt (gsi);
+	  if (!is_gimple_assign (stmt)
+	      || gimple_assign_rhs_code (stmt) != ADDR_EXPR
+	      || is_gimple_invariant_address (gimple_assign_rhs1 (stmt)))
+	    {
+	      gsi_next (&gsi);
+	      continue;
+	    }
+
+	  /* Lower ADDR_EXPR assignments:
+	       _4 = &b[i_9];
+	     into
+	       _1 = (sizetype) i_9;
+	       _7 = _1 * 4;
+	       _4 = &b + _7;
+	     This ought to aid the vectorizer and expose CSE opportunities.
+	  */
+
+	  tree expr = gimple_assign_rhs1 (stmt);
+	  HOST_WIDE_INT bitsize, bitpos;
+	  tree base, offset;
+	  machine_mode mode;
+	  int volatilep = 0, unsignedp = 0;
+	  base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
+				      &bitpos, &offset, &mode, &unsignedp,
+				      &volatilep, false);
+	  gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0);
+	  if (offset != NULL_TREE)
+	    {
+	      if (bitpos != 0)
+		offset = size_binop (PLUS_EXPR, offset,
+				     size_int (bitpos / BITS_PER_UNIT));
+	      offset = force_gimple_operand_gsi (&gsi, offset, true, NULL,
+						 true, GSI_SAME_STMT);
+	      base = build_fold_addr_expr (base);
+	      base = force_gimple_operand_gsi (&gsi, base, true, NULL,
+					       true, GSI_SAME_STMT);
+	      gimple g = gimple_build_assign (gimple_assign_lhs (stmt),
+					      POINTER_PLUS_EXPR, base, offset);
+	      gsi_replace (&gsi, g, false);
+	    }
+	  gsi_next (&gsi);
+	}
+    }
+
+  return 0;
+}
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_laddress (gcc::context *ctxt)
+{
+  return new pass_laddress (ctxt);
+}

	Marek

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On Fri, 3 Jul 2015, Marek Polacek wrote:

> This patch implements a new pass, called laddress, which deals with
> lowering ADDR_EXPR assignments.  Such lowering ought to help the
> vectorizer, but it also could expose more CSE opportunities, maybe
> help reassoc, etc.  It's only active when optimize != 0.
> 
> So e.g.
>   _1 = (sizetype) i_9;
>   _7 = _1 * 4;
>   _4 = &b + _7;
> instead of
>   _4 = &b[i_9];
> 
> This triggered 14105 times during the regtest and 6392 times during
> the bootstrap.
> 
> The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> to a bug in the vectorizer.  Jakub has a patch and knows the details.
> As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> (that was the motivation of this pass).
> 
> This doesn't introduce any kind of verification nor PROP_laddress.
> Don't know if we want that, but hopefully it can be done as a follow-up
> if we do.

Yes.  At the moment nothing requires lowered address form so this is
merely an optimization (and not a bug for some later pass to
re-introduce un-lowered non-invariant addresses).  I can imagine
that for example IVOPTs could be simplified if we didn't have this
kind of addresses in the IL.

> Do we want to move some optimizations into this new pass, e.g.
> from fwprop?

I think we might want to re-try forwprop_into_addr_expr before lowering
the address.  Well, but that's maybe just over-cautionous.

> Thoughts?

Please move the pass before crited, crited and pre are supposed to
go together.

Otherwise looks ok to me.

Thanks,
Richard.

> Bootstrapped/regtested on x86_64-linux.
> 
> 2015-07-03  Marek Polacek  <polacek@redhat.com>
> 
> 	PR tree-optimization/66718
> 	* Makefile.in (OBJS): Add tree-ssa-laddress.o. 
> 	* passes.def: Schedule pass_laddress.
> 	* timevar.def (DEFTIMEVAR): Add TV_TREE_LADDRESS.
> 	* tree-pass.h (make_pass_laddress): Declare.
> 	* tree-ssa-laddress.c: New file.
> 
> 	* gcc.dg/vect/vect-126.c: New test.
> 
> diff --git gcc/Makefile.in gcc/Makefile.in
> index 89eda96..2574b98 100644
> --- gcc/Makefile.in
> +++ gcc/Makefile.in
> @@ -1447,6 +1447,7 @@ OBJS = \
>  	tree-ssa-dse.o \
>  	tree-ssa-forwprop.o \
>  	tree-ssa-ifcombine.o \
> +	tree-ssa-laddress.o \
>  	tree-ssa-live.o \
>  	tree-ssa-loop-ch.o \
>  	tree-ssa-loop-im.o \
> diff --git gcc/passes.def gcc/passes.def
> index 0d8356b..ac16e8a 100644
> --- gcc/passes.def
> +++ gcc/passes.def
> @@ -214,6 +214,7 @@ along with GCC; see the file COPYING3.  If not see
>        NEXT_PASS (pass_cse_sincos);
>        NEXT_PASS (pass_optimize_bswap);
>        NEXT_PASS (pass_split_crit_edges);
> +      NEXT_PASS (pass_laddress);
>        NEXT_PASS (pass_pre);
>        NEXT_PASS (pass_sink_code);
>        NEXT_PASS (pass_asan);
> diff --git gcc/testsuite/gcc.dg/vect/vect-126.c gcc/testsuite/gcc.dg/vect/vect-126.c
> index e69de29..66a5821 100644
> --- gcc/testsuite/gcc.dg/vect/vect-126.c
> +++ gcc/testsuite/gcc.dg/vect/vect-126.c
> @@ -0,0 +1,64 @@
> +/* PR tree-optimization/66718 */
> +/* { dg-do compile } */
> +/* { dg-additional-options "-mavx2" { target avx_runtime } } */
> +
> +int *a[1024], b[1024];
> +struct S { int u, v, w, x; };
> +struct S c[1024];
> +int d[1024][10];
> +
> +void
> +f0 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &b[0];
> +}
> +
> +void
> +f1 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    {
> +      int *p = &b[0];
> +      a[i] = p + i;
> +    }
> +}
> +
> +void
> +f2 (int *p)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &p[i];
> +}
> +
> +void
> +f3 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &b[i];
> +}
> +
> +void
> +f4 (void)
> +{
> +  int *p = &c[0].v;
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &p[4 * i];
> +}
> +
> +void
> +f5 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &c[i].v;
> +}
> +
> +void
> +f6 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    for (unsigned int j = 0; j < 10; j++)
> +      a[i] = &d[i][j];
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops in function" 7 "vect" { target vect_condition } } } */
> diff --git gcc/timevar.def gcc/timevar.def
> index efac4b7..fcc2fe0 100644
> --- gcc/timevar.def
> +++ gcc/timevar.def
> @@ -275,6 +275,7 @@ DEFTIMEVAR (TV_GIMPLE_SLSR           , "straight-line strength reduction")
>  DEFTIMEVAR (TV_VTABLE_VERIFICATION   , "vtable verification")
>  DEFTIMEVAR (TV_TREE_UBSAN            , "tree ubsan")
>  DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
> +DEFTIMEVAR (TV_TREE_LADDRESS         , "address lowering")
>  
>  /* Everything else in rest_of_compilation not included above.  */
>  DEFTIMEVAR (TV_EARLY_LOCAL	     , "early local passes")
> diff --git gcc/tree-pass.h gcc/tree-pass.h
> index 2808dad..c47b22e 100644
> --- gcc/tree-pass.h
> +++ gcc/tree-pass.h
> @@ -393,6 +393,7 @@ extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
> +extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
>  extern unsigned int tail_merge_optimize (unsigned int);
>  extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);
> diff --git gcc/tree-ssa-laddress.c gcc/tree-ssa-laddress.c
> index e69de29..3f69d7d 100644
> --- gcc/tree-ssa-laddress.c
> +++ gcc/tree-ssa-laddress.c
> @@ -0,0 +1,137 @@
> +/* Lower and optimize address expressions.
> +   Copyright (C) 2015 Free Software Foundation, Inc.
> +   Contributed by Marek Polacek <polacek@redhat.com>
> +
> +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"
> +#include "system.h"
> +#include "coretypes.h"
> +#include "alias.h"
> +#include "predict.h"
> +#include "tm.h"
> +#include "function.h"
> +#include "dominance.h"
> +#include "cfg.h"
> +#include "basic-block.h"
> +#include "tree-ssa-alias.h"
> +#include "symtab.h"
> +#include "tree.h"
> +#include "stringpool.h"
> +#include "tree-ssanames.h"
> +#include "fold-const.h"
> +#include "gimple-expr.h"
> +#include "gimple.h"
> +#include "gimplify.h"
> +#include "gimple-iterator.h"
> +#include "gimplify-me.h"
> +#include "tree-pass.h"
> +
> +
> +namespace {
> +
> +const pass_data pass_data_laddress =
> +{
> +  GIMPLE_PASS, /* type */
> +  "laddress", /* name */
> +  OPTGROUP_NONE, /* optinfo_flags */
> +  TV_TREE_LADDRESS, /* tv_id */
> +  ( PROP_cfg | PROP_ssa ), /* properties_required */
> +  0, /* properties_provided */
> +  0, /* properties_destroyed */
> +  0, /* todo_flags_start */
> +  0, /* todo_flags_finish */
> +};
> +
> +class pass_laddress : public gimple_opt_pass
> +{
> +public:
> +  pass_laddress (gcc::context *ctxt)
> +    : gimple_opt_pass (pass_data_laddress, ctxt)
> +  {}
> +
> +  /* opt_pass methods: */
> +  opt_pass * clone () { return new pass_laddress (m_ctxt); }
> +  virtual bool gate (function *) { return optimize != 0; }
> +  virtual unsigned int execute (function *);
> +
> +}; // class pass_laddress
> +
> +unsigned int
> +pass_laddress::execute (function *fun)
> +{
> +  basic_block bb;
> +
> +  FOR_EACH_BB_FN (bb, fun)
> +    {
> +      for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
> +	{
> +	  gimple stmt = gsi_stmt (gsi);
> +	  if (!is_gimple_assign (stmt)
> +	      || gimple_assign_rhs_code (stmt) != ADDR_EXPR
> +	      || is_gimple_invariant_address (gimple_assign_rhs1 (stmt)))
> +	    {
> +	      gsi_next (&gsi);
> +	      continue;
> +	    }
> +
> +	  /* Lower ADDR_EXPR assignments:
> +	       _4 = &b[i_9];
> +	     into
> +	       _1 = (sizetype) i_9;
> +	       _7 = _1 * 4;
> +	       _4 = &b + _7;
> +	     This ought to aid the vectorizer and expose CSE opportunities.
> +	  */
> +
> +	  tree expr = gimple_assign_rhs1 (stmt);
> +	  HOST_WIDE_INT bitsize, bitpos;
> +	  tree base, offset;
> +	  machine_mode mode;
> +	  int volatilep = 0, unsignedp = 0;
> +	  base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
> +				      &bitpos, &offset, &mode, &unsignedp,
> +				      &volatilep, false);
> +	  gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0);
> +	  if (offset != NULL_TREE)
> +	    {
> +	      if (bitpos != 0)
> +		offset = size_binop (PLUS_EXPR, offset,
> +				     size_int (bitpos / BITS_PER_UNIT));
> +	      offset = force_gimple_operand_gsi (&gsi, offset, true, NULL,
> +						 true, GSI_SAME_STMT);
> +	      base = build_fold_addr_expr (base);
> +	      base = force_gimple_operand_gsi (&gsi, base, true, NULL,
> +					       true, GSI_SAME_STMT);
> +	      gimple g = gimple_build_assign (gimple_assign_lhs (stmt),
> +					      POINTER_PLUS_EXPR, base, offset);
> +	      gsi_replace (&gsi, g, false);
> +	    }
> +	  gsi_next (&gsi);
> +	}
> +    }
> +
> +  return 0;
> +}
> +
> +} // anon namespace
> +
> +gimple_opt_pass *
> +make_pass_laddress (gcc::context *ctxt)
> +{
> +  return new pass_laddress (ctxt);
> +}
> 
> 	Marek
> 
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Dilip Upmanyu, Graham Norton, HRB 21284 (AG Nuernberg)

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On Fri, 3 Jul 2015, Richard Biener wrote:

> On Fri, 3 Jul 2015, Marek Polacek wrote:
> 
> > This patch implements a new pass, called laddress, which deals with
> > lowering ADDR_EXPR assignments.  Such lowering ought to help the
> > vectorizer, but it also could expose more CSE opportunities, maybe
> > help reassoc, etc.  It's only active when optimize != 0.
> > 
> > So e.g.
> >   _1 = (sizetype) i_9;
> >   _7 = _1 * 4;
> >   _4 = &b + _7;
> > instead of
> >   _4 = &b[i_9];
> > 
> > This triggered 14105 times during the regtest and 6392 times during
> > the bootstrap.
> > 
> > The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> > to a bug in the vectorizer.  Jakub has a patch and knows the details.
> > As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> > (that was the motivation of this pass).
> > 
> > This doesn't introduce any kind of verification nor PROP_laddress.
> > Don't know if we want that, but hopefully it can be done as a follow-up
> > if we do.
> 
> Yes.  At the moment nothing requires lowered address form so this is
> merely an optimization (and not a bug for some later pass to
> re-introduce un-lowered non-invariant addresses).  I can imagine
> that for example IVOPTs could be simplified if we didn't have this
> kind of addresses in the IL.
> 
> > Do we want to move some optimizations into this new pass, e.g.
> > from fwprop?
> 
> I think we might want to re-try forwprop_into_addr_expr before lowering
> the address.  Well, but that's maybe just over-cautionous.
> 
> > Thoughts?
> 
> Please move the pass before crited, crited and pre are supposed to
> go together.
> 
> Otherwise looks ok to me.
> 
> Thanks,
> Richard.
> 
> > Bootstrapped/regtested on x86_64-linux.
> > 
> > 2015-07-03  Marek Polacek  <polacek@redhat.com>
> > 
> > 	PR tree-optimization/66718
> > 	* Makefile.in (OBJS): Add tree-ssa-laddress.o. 
> > 	* passes.def: Schedule pass_laddress.
> > 	* timevar.def (DEFTIMEVAR): Add TV_TREE_LADDRESS.
> > 	* tree-pass.h (make_pass_laddress): Declare.
> > 	* tree-ssa-laddress.c: New file.
> > 
> > 	* gcc.dg/vect/vect-126.c: New test.
> > 
> > diff --git gcc/Makefile.in gcc/Makefile.in
> > index 89eda96..2574b98 100644
> > --- gcc/Makefile.in
> > +++ gcc/Makefile.in
> > @@ -1447,6 +1447,7 @@ OBJS = \
> >  	tree-ssa-dse.o \
> >  	tree-ssa-forwprop.o \
> >  	tree-ssa-ifcombine.o \
> > +	tree-ssa-laddress.o \

I'd say gimple-laddress.c is a better fit.  There is nothing
SSA specific in the pass and 'tree' is legacy...

> >  	tree-ssa-live.o \
> >  	tree-ssa-loop-ch.o \
> >  	tree-ssa-loop-im.o \
> > diff --git gcc/passes.def gcc/passes.def
> > index 0d8356b..ac16e8a 100644
> > --- gcc/passes.def
> > +++ gcc/passes.def
> > @@ -214,6 +214,7 @@ along with GCC; see the file COPYING3.  If not see
> >        NEXT_PASS (pass_cse_sincos);
> >        NEXT_PASS (pass_optimize_bswap);
> >        NEXT_PASS (pass_split_crit_edges);
> > +      NEXT_PASS (pass_laddress);
> >        NEXT_PASS (pass_pre);
> >        NEXT_PASS (pass_sink_code);
> >        NEXT_PASS (pass_asan);
> > diff --git gcc/testsuite/gcc.dg/vect/vect-126.c gcc/testsuite/gcc.dg/vect/vect-126.c
> > index e69de29..66a5821 100644
> > --- gcc/testsuite/gcc.dg/vect/vect-126.c
> > +++ gcc/testsuite/gcc.dg/vect/vect-126.c
> > @@ -0,0 +1,64 @@
> > +/* PR tree-optimization/66718 */
> > +/* { dg-do compile } */
> > +/* { dg-additional-options "-mavx2" { target avx_runtime } } */
> > +
> > +int *a[1024], b[1024];
> > +struct S { int u, v, w, x; };
> > +struct S c[1024];
> > +int d[1024][10];
> > +
> > +void
> > +f0 (void)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    a[i] = &b[0];
> > +}
> > +
> > +void
> > +f1 (void)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    {
> > +      int *p = &b[0];
> > +      a[i] = p + i;
> > +    }
> > +}
> > +
> > +void
> > +f2 (int *p)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    a[i] = &p[i];
> > +}
> > +
> > +void
> > +f3 (void)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    a[i] = &b[i];
> > +}
> > +
> > +void
> > +f4 (void)
> > +{
> > +  int *p = &c[0].v;
> > +  for (int i = 0; i < 1024; i++)
> > +    a[i] = &p[4 * i];
> > +}
> > +
> > +void
> > +f5 (void)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    a[i] = &c[i].v;
> > +}
> > +
> > +void
> > +f6 (void)
> > +{
> > +  for (int i = 0; i < 1024; i++)
> > +    for (unsigned int j = 0; j < 10; j++)
> > +      a[i] = &d[i][j];
> > +}
> > +
> > +/* { dg-final { scan-tree-dump-times "vectorized 1 loops in function" 7 "vect" { target vect_condition } } } */
> > diff --git gcc/timevar.def gcc/timevar.def
> > index efac4b7..fcc2fe0 100644
> > --- gcc/timevar.def
> > +++ gcc/timevar.def
> > @@ -275,6 +275,7 @@ DEFTIMEVAR (TV_GIMPLE_SLSR           , "straight-line strength reduction")
> >  DEFTIMEVAR (TV_VTABLE_VERIFICATION   , "vtable verification")
> >  DEFTIMEVAR (TV_TREE_UBSAN            , "tree ubsan")
> >  DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
> > +DEFTIMEVAR (TV_TREE_LADDRESS         , "address lowering")
> >  
> >  /* Everything else in rest_of_compilation not included above.  */
> >  DEFTIMEVAR (TV_EARLY_LOCAL	     , "early local passes")
> > diff --git gcc/tree-pass.h gcc/tree-pass.h
> > index 2808dad..c47b22e 100644
> > --- gcc/tree-pass.h
> > +++ gcc/tree-pass.h
> > @@ -393,6 +393,7 @@ extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
> >  extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
> >  extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
> >  extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
> > +extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
> >  extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
> >  extern unsigned int tail_merge_optimize (unsigned int);
> >  extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);
> > diff --git gcc/tree-ssa-laddress.c gcc/tree-ssa-laddress.c
> > index e69de29..3f69d7d 100644
> > --- gcc/tree-ssa-laddress.c
> > +++ gcc/tree-ssa-laddress.c
> > @@ -0,0 +1,137 @@
> > +/* Lower and optimize address expressions.
> > +   Copyright (C) 2015 Free Software Foundation, Inc.
> > +   Contributed by Marek Polacek <polacek@redhat.com>
> > +
> > +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"
> > +#include "system.h"
> > +#include "coretypes.h"
> > +#include "alias.h"
> > +#include "predict.h"
> > +#include "tm.h"
> > +#include "function.h"
> > +#include "dominance.h"
> > +#include "cfg.h"
> > +#include "basic-block.h"
> > +#include "tree-ssa-alias.h"
> > +#include "symtab.h"
> > +#include "tree.h"
> > +#include "stringpool.h"
> > +#include "tree-ssanames.h"
> > +#include "fold-const.h"
> > +#include "gimple-expr.h"
> > +#include "gimple.h"
> > +#include "gimplify.h"
> > +#include "gimple-iterator.h"
> > +#include "gimplify-me.h"
> > +#include "tree-pass.h"
> > +
> > +
> > +namespace {
> > +
> > +const pass_data pass_data_laddress =
> > +{
> > +  GIMPLE_PASS, /* type */
> > +  "laddress", /* name */
> > +  OPTGROUP_NONE, /* optinfo_flags */
> > +  TV_TREE_LADDRESS, /* tv_id */
> > +  ( PROP_cfg | PROP_ssa ), /* properties_required */
> > +  0, /* properties_provided */
> > +  0, /* properties_destroyed */
> > +  0, /* todo_flags_start */
> > +  0, /* todo_flags_finish */
> > +};
> > +
> > +class pass_laddress : public gimple_opt_pass
> > +{
> > +public:
> > +  pass_laddress (gcc::context *ctxt)
> > +    : gimple_opt_pass (pass_data_laddress, ctxt)
> > +  {}
> > +
> > +  /* opt_pass methods: */
> > +  opt_pass * clone () { return new pass_laddress (m_ctxt); }
> > +  virtual bool gate (function *) { return optimize != 0; }
> > +  virtual unsigned int execute (function *);
> > +
> > +}; // class pass_laddress
> > +
> > +unsigned int
> > +pass_laddress::execute (function *fun)
> > +{
> > +  basic_block bb;
> > +
> > +  FOR_EACH_BB_FN (bb, fun)
> > +    {
> > +      for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
> > +	{
> > +	  gimple stmt = gsi_stmt (gsi);
> > +	  if (!is_gimple_assign (stmt)
> > +	      || gimple_assign_rhs_code (stmt) != ADDR_EXPR
> > +	      || is_gimple_invariant_address (gimple_assign_rhs1 (stmt)))
> > +	    {
> > +	      gsi_next (&gsi);
> > +	      continue;
> > +	    }
> > +
> > +	  /* Lower ADDR_EXPR assignments:
> > +	       _4 = &b[i_9];
> > +	     into
> > +	       _1 = (sizetype) i_9;
> > +	       _7 = _1 * 4;
> > +	       _4 = &b + _7;
> > +	     This ought to aid the vectorizer and expose CSE opportunities.
> > +	  */
> > +
> > +	  tree expr = gimple_assign_rhs1 (stmt);
> > +	  HOST_WIDE_INT bitsize, bitpos;
> > +	  tree base, offset;
> > +	  machine_mode mode;
> > +	  int volatilep = 0, unsignedp = 0;
> > +	  base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
> > +				      &bitpos, &offset, &mode, &unsignedp,
> > +				      &volatilep, false);
> > +	  gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0);
> > +	  if (offset != NULL_TREE)
> > +	    {
> > +	      if (bitpos != 0)
> > +		offset = size_binop (PLUS_EXPR, offset,
> > +				     size_int (bitpos / BITS_PER_UNIT));
> > +	      offset = force_gimple_operand_gsi (&gsi, offset, true, NULL,
> > +						 true, GSI_SAME_STMT);
> > +	      base = build_fold_addr_expr (base);
> > +	      base = force_gimple_operand_gsi (&gsi, base, true, NULL,
> > +					       true, GSI_SAME_STMT);
> > +	      gimple g = gimple_build_assign (gimple_assign_lhs (stmt),
> > +					      POINTER_PLUS_EXPR, base, offset);
> > +	      gsi_replace (&gsi, g, false);
> > +	    }
> > +	  gsi_next (&gsi);
> > +	}
> > +    }
> > +
> > +  return 0;
> > +}
> > +
> > +} // anon namespace
> > +
> > +gimple_opt_pass *
> > +make_pass_laddress (gcc::context *ctxt)
> > +{
> > +  return new pass_laddress (ctxt);
> > +}
> > 
> > 	Marek
> > 
> > 
> 
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Dilip Upmanyu, Graham Norton, HRB 21284 (AG Nuernberg)

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Fri, Jul 03, 2015 at 03:41:29PM +0200, Richard Biener wrote:
> > The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> > to a bug in the vectorizer.  Jakub has a patch and knows the details.
> > As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> > (that was the motivation of this pass).

Here is the fix for that.

The problem is that for simd clone calls, if they have void return type,
STMT_VINFO_VECTYPE is NULL.  If vectorize_simd_clone_call succeeds,
that is fine, but if it doesn't, we can fall into all the other
vectorizable_* functions, and some of them compute some variables
IMHO prematurely.  It doesn't make sense to compute nunits/ncopies
etc. if stmt isn't even an assignment etc.
So, this patch adjusts the few routines that had this problem,
so that we check is_gimple_assign and gimple_assign_rhs_code or whatever
is the quick GIMPLE test those functions use to find if stmt is of interest
to them, and only when it is, compute whatever they need later.
As NULL STMT_VINFO_VECTYPE can happen only for calls, all these functions
don't ICE anymore.

Ok for trunk if it passes bootstrap/regtest?

In the pr59984.c testcase, with Marek's patch and this patch, one loop in
test is already vectorized (the ICE was on the other one), I'll work on
recognizing multiples of GOMP_SIMD_LANE () as linear next, so that we
vectorize also the loop with bar.  Without Marek's patch we weren't
vectorizing any of the two loops.

2015-07-03  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/66718
	* tree-vect-stmts.c (vectorizable_assignment, vectorizable_store,
	vectorizable_load, vectorizable_condition): Move vectype,
	nunits, ncopies computation after checking what kind of statement
	stmt is.

--- gcc/tree-vect-stmts.c.jj	2015-06-30 14:08:45.000000000 +0200
+++ gcc/tree-vect-stmts.c	2015-07-03 14:06:28.843573210 +0200
@@ -4043,13 +4043,11 @@ vectorizable_assignment (gimple stmt, gi
   tree scalar_dest;
   tree op;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   tree new_temp;
   tree def;
   gimple def_stmt;
   enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
-  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int i, j;
   vec<tree> vec_oprnds = vNULL;
@@ -4060,16 +4058,6 @@ vectorizable_assignment (gimple stmt, gi
   enum tree_code code;
   tree vectype_in;
 
-  /* Multiple types in SLP are handled by creating the appropriate number of
-     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
-     case of SLP.  */
-  if (slp_node || PURE_SLP_STMT (stmt_info))
-    ncopies = 1;
-  else
-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
-
-  gcc_assert (ncopies >= 1);
-
   if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
     return false;
 
@@ -4095,6 +4083,19 @@ vectorizable_assignment (gimple stmt, gi
   if (code == VIEW_CONVERT_EXPR)
     op = TREE_OPERAND (op, 0);
 
+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
+
+  /* Multiple types in SLP are handled by creating the appropriate number of
+     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
+     case of SLP.  */
+  if (slp_node || PURE_SLP_STMT (stmt_info))
+    ncopies = 1;
+  else
+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
+
+  gcc_assert (ncopies >= 1);
+
   if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
 			     &def_stmt, &def, &dt[0], &vectype_in))
     {
@@ -5006,7 +5007,6 @@ vectorizable_store (gimple stmt, gimple_
   tree vec_oprnd = NULL_TREE;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr = NULL;
-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   tree elem_type;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop *loop = NULL;
@@ -5020,7 +5020,6 @@ vectorizable_store (gimple stmt, gimple_
   tree dataref_ptr = NULL_TREE;
   tree dataref_offset = NULL_TREE;
   gimple ptr_incr = NULL;
-  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int j;
   gimple next_stmt, first_stmt = NULL;
@@ -5039,28 +5038,6 @@ vectorizable_store (gimple stmt, gimple_
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   tree aggr_type;
 
-  if (loop_vinfo)
-    loop = LOOP_VINFO_LOOP (loop_vinfo);
-
-  /* Multiple types in SLP are handled by creating the appropriate number of
-     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
-     case of SLP.  */
-  if (slp || PURE_SLP_STMT (stmt_info))
-    ncopies = 1;
-  else
-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
-
-  gcc_assert (ncopies >= 1);
-
-  /* FORNOW. This restriction should be relaxed.  */
-  if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
-    {
-      if (dump_enabled_p ())
-        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
-                         "multiple types in nested loop.\n");
-      return false;
-    }
-
   if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
     return false;
 
@@ -5086,6 +5063,32 @@ vectorizable_store (gimple stmt, gimple_
     return false;
 
   gcc_assert (gimple_assign_single_p (stmt));
+
+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
+
+  if (loop_vinfo)
+    loop = LOOP_VINFO_LOOP (loop_vinfo);
+
+  /* Multiple types in SLP are handled by creating the appropriate number of
+     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
+     case of SLP.  */
+  if (slp || PURE_SLP_STMT (stmt_info))
+    ncopies = 1;
+  else
+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
+
+  gcc_assert (ncopies >= 1);
+
+  /* FORNOW. This restriction should be relaxed.  */
+  if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
+    {
+      if (dump_enabled_p ())
+        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+                         "multiple types in nested loop.\n");
+      return false;
+    }
+
   op = gimple_assign_rhs1 (stmt);
   if (!vect_is_simple_use (op, stmt, loop_vinfo, bb_vinfo, &def_stmt,
 			   &def, &dt))
@@ -5834,7 +5837,6 @@ vectorizable_load (gimple stmt, gimple_s
   struct loop *containing_loop = (gimple_bb (stmt))->loop_father;
   bool nested_in_vect_loop = false;
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr = NULL;
-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   tree elem_type;
   tree new_temp;
   machine_mode mode;
@@ -5844,7 +5846,6 @@ vectorizable_load (gimple stmt, gimple_s
   tree dataref_ptr = NULL_TREE;
   tree dataref_offset = NULL_TREE;
   gimple ptr_incr = NULL;
-  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int i, j, group_size = -1, group_gap_adj;
   tree msq = NULL_TREE, lsq;
@@ -5872,6 +5873,37 @@ vectorizable_load (gimple stmt, gimple_s
   int gather_scale = 1;
   enum vect_def_type gather_dt = vect_unknown_def_type;
 
+  if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
+    return false;
+
+  if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_internal_def)
+    return false;
+
+  /* Is vectorizable load? */
+  if (!is_gimple_assign (stmt))
+    return false;
+
+  scalar_dest = gimple_assign_lhs (stmt);
+  if (TREE_CODE (scalar_dest) != SSA_NAME)
+    return false;
+
+  code = gimple_assign_rhs_code (stmt);
+  if (code != ARRAY_REF
+      && code != BIT_FIELD_REF
+      && code != INDIRECT_REF
+      && code != COMPONENT_REF
+      && code != IMAGPART_EXPR
+      && code != REALPART_EXPR
+      && code != MEM_REF
+      && TREE_CODE_CLASS (code) != tcc_declaration)
+    return false;
+
+  if (!STMT_VINFO_DATA_REF (stmt_info))
+    return false;
+
+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
+
   if (loop_vinfo)
     {
       loop = LOOP_VINFO_LOOP (loop_vinfo);
@@ -5914,34 +5946,6 @@ vectorizable_load (gimple stmt, gimple_s
       return false;
     }
 
-  if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
-    return false;
-
-  if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_internal_def)
-    return false;
-
-  /* Is vectorizable load? */
-  if (!is_gimple_assign (stmt))
-    return false;
-
-  scalar_dest = gimple_assign_lhs (stmt);
-  if (TREE_CODE (scalar_dest) != SSA_NAME)
-    return false;
-
-  code = gimple_assign_rhs_code (stmt);
-  if (code != ARRAY_REF
-      && code != BIT_FIELD_REF
-      && code != INDIRECT_REF
-      && code != COMPONENT_REF
-      && code != IMAGPART_EXPR
-      && code != REALPART_EXPR
-      && code != MEM_REF
-      && TREE_CODE_CLASS (code) != tcc_declaration)
-    return false;
-
-  if (!STMT_VINFO_DATA_REF (stmt_info))
-    return false;
-
   elem_type = TREE_TYPE (vectype);
   mode = TYPE_MODE (vectype);
 
@@ -7021,7 +7025,6 @@ vectorizable_condition (gimple stmt, gim
   tree vec_dest = NULL_TREE;
   tree cond_expr, then_clause, else_clause;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   tree comp_vectype = NULL_TREE;
   tree vec_cond_lhs = NULL_TREE, vec_cond_rhs = NULL_TREE;
   tree vec_then_clause = NULL_TREE, vec_else_clause = NULL_TREE;
@@ -7030,7 +7033,6 @@ vectorizable_condition (gimple stmt, gim
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   tree def;
   enum vect_def_type dt, dts[4];
-  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   enum tree_code code;
   stmt_vec_info prev_stmt_info = NULL;
@@ -7042,15 +7044,6 @@ vectorizable_condition (gimple stmt, gim
   vec<tree> vec_oprnds3 = vNULL;
   tree vec_cmp_type;
 
-  if (slp_node || PURE_SLP_STMT (stmt_info))
-    ncopies = 1;
-  else
-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
-
-  gcc_assert (ncopies >= 1);
-  if (reduc_index && ncopies > 1)
-    return false; /* FORNOW */
-
   if (reduc_index && STMT_SLP_TYPE (stmt_info))
     return false;
 
@@ -7080,6 +7073,18 @@ vectorizable_condition (gimple stmt, gim
   if (code != COND_EXPR)
     return false;
 
+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
+
+  if (slp_node || PURE_SLP_STMT (stmt_info))
+    ncopies = 1;
+  else
+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
+
+  gcc_assert (ncopies >= 1);
+  if (reduc_index && ncopies > 1)
+    return false; /* FORNOW */
+
   cond_expr = gimple_assign_rhs1 (stmt);
   then_clause = gimple_assign_rhs2 (stmt);
   else_clause = gimple_assign_rhs3 (stmt);


	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On July 3, 2015 4:06:26 PM GMT+02:00, Jakub Jelinek <jakub@redhat.com> wrote:
>On Fri, Jul 03, 2015 at 03:41:29PM +0200, Richard Biener wrote:
>> > The fallout (at least on x86_64) is surprisingly small, i.e. none,
>just
>> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is
>due
>> > to a bug in the vectorizer.  Jakub has a patch and knows the
>details.
>> > As the test shows, we're now able to vectorize ADDR_EXPR of
>non-invariants
>> > (that was the motivation of this pass).
>
>Here is the fix for that.
>
>The problem is that for simd clone calls, if they have void return
>type,
>STMT_VINFO_VECTYPE is NULL.  If vectorize_simd_clone_call succeeds,
>that is fine, but if it doesn't, we can fall into all the other
>vectorizable_* functions, and some of them compute some variables
>IMHO prematurely.  It doesn't make sense to compute nunits/ncopies
>etc. if stmt isn't even an assignment etc.
>So, this patch adjusts the few routines that had this problem,
>so that we check is_gimple_assign and gimple_assign_rhs_code or
>whatever
>is the quick GIMPLE test those functions use to find if stmt is of
>interest
>to them, and only when it is, compute whatever they need later.
>As NULL STMT_VINFO_VECTYPE can happen only for calls, all these
>functions
>don't ICE anymore.
>
>Ok for trunk if it passes bootstrap/regtest?

OK.

Thanks,
Richard.

>In the pr59984.c testcase, with Marek's patch and this patch, one loop
>in
>test is already vectorized (the ICE was on the other one), I'll work on
>recognizing multiples of GOMP_SIMD_LANE () as linear next, so that we
>vectorize also the loop with bar.  Without Marek's patch we weren't
>vectorizing any of the two loops.
>
>2015-07-03  Jakub Jelinek  <jakub@redhat.com>
>
>	PR tree-optimization/66718
>	* tree-vect-stmts.c (vectorizable_assignment, vectorizable_store,
>	vectorizable_load, vectorizable_condition): Move vectype,
>	nunits, ncopies computation after checking what kind of statement
>	stmt is.
>
>--- gcc/tree-vect-stmts.c.jj	2015-06-30 14:08:45.000000000 +0200
>+++ gcc/tree-vect-stmts.c	2015-07-03 14:06:28.843573210 +0200
>@@ -4043,13 +4043,11 @@ vectorizable_assignment (gimple stmt, gi
>   tree scalar_dest;
>   tree op;
>   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
>-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
>   tree new_temp;
>   tree def;
>   gimple def_stmt;
>enum vect_def_type dt[2] = {vect_unknown_def_type,
>vect_unknown_def_type};
>-  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>   int ncopies;
>   int i, j;
>   vec<tree> vec_oprnds = vNULL;
>@@ -4060,16 +4058,6 @@ vectorizable_assignment (gimple stmt, gi
>   enum tree_code code;
>   tree vectype_in;
> 
>-  /* Multiple types in SLP are handled by creating the appropriate
>number of
>-     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
>-     case of SLP.  */
>-  if (slp_node || PURE_SLP_STMT (stmt_info))
>-    ncopies = 1;
>-  else
>-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>-
>-  gcc_assert (ncopies >= 1);
>-
>   if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
>     return false;
> 
>@@ -4095,6 +4083,19 @@ vectorizable_assignment (gimple stmt, gi
>   if (code == VIEW_CONVERT_EXPR)
>     op = TREE_OPERAND (op, 0);
> 
>+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>+  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>+
>+  /* Multiple types in SLP are handled by creating the appropriate
>number of
>+     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
>+     case of SLP.  */
>+  if (slp_node || PURE_SLP_STMT (stmt_info))
>+    ncopies = 1;
>+  else
>+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>+
>+  gcc_assert (ncopies >= 1);
>+
>   if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
> 			     &def_stmt, &def, &dt[0], &vectype_in))
>     {
>@@ -5006,7 +5007,6 @@ vectorizable_store (gimple stmt, gimple_
>   tree vec_oprnd = NULL_TREE;
>   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
>struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr
>= NULL;
>-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>   tree elem_type;
>   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
>   struct loop *loop = NULL;
>@@ -5020,7 +5020,6 @@ vectorizable_store (gimple stmt, gimple_
>   tree dataref_ptr = NULL_TREE;
>   tree dataref_offset = NULL_TREE;
>   gimple ptr_incr = NULL;
>-  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>   int ncopies;
>   int j;
>   gimple next_stmt, first_stmt = NULL;
>@@ -5039,28 +5038,6 @@ vectorizable_store (gimple stmt, gimple_
>   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
>   tree aggr_type;
> 
>-  if (loop_vinfo)
>-    loop = LOOP_VINFO_LOOP (loop_vinfo);
>-
>-  /* Multiple types in SLP are handled by creating the appropriate
>number of
>-     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
>-     case of SLP.  */
>-  if (slp || PURE_SLP_STMT (stmt_info))
>-    ncopies = 1;
>-  else
>-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>-
>-  gcc_assert (ncopies >= 1);
>-
>-  /* FORNOW. This restriction should be relaxed.  */
>-  if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
>-    {
>-      if (dump_enabled_p ())
>-        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>-                         "multiple types in nested loop.\n");
>-      return false;
>-    }
>-
>   if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
>     return false;
> 
>@@ -5086,6 +5063,32 @@ vectorizable_store (gimple stmt, gimple_
>     return false;
> 
>   gcc_assert (gimple_assign_single_p (stmt));
>+
>+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>+  unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>+
>+  if (loop_vinfo)
>+    loop = LOOP_VINFO_LOOP (loop_vinfo);
>+
>+  /* Multiple types in SLP are handled by creating the appropriate
>number of
>+     vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
>+     case of SLP.  */
>+  if (slp || PURE_SLP_STMT (stmt_info))
>+    ncopies = 1;
>+  else
>+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>+
>+  gcc_assert (ncopies >= 1);
>+
>+  /* FORNOW. This restriction should be relaxed.  */
>+  if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
>+    {
>+      if (dump_enabled_p ())
>+        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>+                         "multiple types in nested loop.\n");
>+      return false;
>+    }
>+
>   op = gimple_assign_rhs1 (stmt);
>   if (!vect_is_simple_use (op, stmt, loop_vinfo, bb_vinfo, &def_stmt,
> 			   &def, &dt))
>@@ -5834,7 +5837,6 @@ vectorizable_load (gimple stmt, gimple_s
>   struct loop *containing_loop = (gimple_bb (stmt))->loop_father;
>   bool nested_in_vect_loop = false;
>struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr
>= NULL;
>-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>   tree elem_type;
>   tree new_temp;
>   machine_mode mode;
>@@ -5844,7 +5846,6 @@ vectorizable_load (gimple stmt, gimple_s
>   tree dataref_ptr = NULL_TREE;
>   tree dataref_offset = NULL_TREE;
>   gimple ptr_incr = NULL;
>-  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>   int ncopies;
>   int i, j, group_size = -1, group_gap_adj;
>   tree msq = NULL_TREE, lsq;
>@@ -5872,6 +5873,37 @@ vectorizable_load (gimple stmt, gimple_s
>   int gather_scale = 1;
>   enum vect_def_type gather_dt = vect_unknown_def_type;
> 
>+  if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
>+    return false;
>+
>+  if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_internal_def)
>+    return false;
>+
>+  /* Is vectorizable load? */
>+  if (!is_gimple_assign (stmt))
>+    return false;
>+
>+  scalar_dest = gimple_assign_lhs (stmt);
>+  if (TREE_CODE (scalar_dest) != SSA_NAME)
>+    return false;
>+
>+  code = gimple_assign_rhs_code (stmt);
>+  if (code != ARRAY_REF
>+      && code != BIT_FIELD_REF
>+      && code != INDIRECT_REF
>+      && code != COMPONENT_REF
>+      && code != IMAGPART_EXPR
>+      && code != REALPART_EXPR
>+      && code != MEM_REF
>+      && TREE_CODE_CLASS (code) != tcc_declaration)
>+    return false;
>+
>+  if (!STMT_VINFO_DATA_REF (stmt_info))
>+    return false;
>+
>+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>+  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>+
>   if (loop_vinfo)
>     {
>       loop = LOOP_VINFO_LOOP (loop_vinfo);
>@@ -5914,34 +5946,6 @@ vectorizable_load (gimple stmt, gimple_s
>       return false;
>     }
> 
>-  if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
>-    return false;
>-
>-  if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_internal_def)
>-    return false;
>-
>-  /* Is vectorizable load? */
>-  if (!is_gimple_assign (stmt))
>-    return false;
>-
>-  scalar_dest = gimple_assign_lhs (stmt);
>-  if (TREE_CODE (scalar_dest) != SSA_NAME)
>-    return false;
>-
>-  code = gimple_assign_rhs_code (stmt);
>-  if (code != ARRAY_REF
>-      && code != BIT_FIELD_REF
>-      && code != INDIRECT_REF
>-      && code != COMPONENT_REF
>-      && code != IMAGPART_EXPR
>-      && code != REALPART_EXPR
>-      && code != MEM_REF
>-      && TREE_CODE_CLASS (code) != tcc_declaration)
>-    return false;
>-
>-  if (!STMT_VINFO_DATA_REF (stmt_info))
>-    return false;
>-
>   elem_type = TREE_TYPE (vectype);
>   mode = TYPE_MODE (vectype);
> 
>@@ -7021,7 +7025,6 @@ vectorizable_condition (gimple stmt, gim
>   tree vec_dest = NULL_TREE;
>   tree cond_expr, then_clause, else_clause;
>   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
>-  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>   tree comp_vectype = NULL_TREE;
>   tree vec_cond_lhs = NULL_TREE, vec_cond_rhs = NULL_TREE;
>   tree vec_then_clause = NULL_TREE, vec_else_clause = NULL_TREE;
>@@ -7030,7 +7033,6 @@ vectorizable_condition (gimple stmt, gim
>   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
>   tree def;
>   enum vect_def_type dt, dts[4];
>-  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>   int ncopies;
>   enum tree_code code;
>   stmt_vec_info prev_stmt_info = NULL;
>@@ -7042,15 +7044,6 @@ vectorizable_condition (gimple stmt, gim
>   vec<tree> vec_oprnds3 = vNULL;
>   tree vec_cmp_type;
> 
>-  if (slp_node || PURE_SLP_STMT (stmt_info))
>-    ncopies = 1;
>-  else
>-    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>-
>-  gcc_assert (ncopies >= 1);
>-  if (reduc_index && ncopies > 1)
>-    return false; /* FORNOW */
>-
>   if (reduc_index && STMT_SLP_TYPE (stmt_info))
>     return false;
> 
>@@ -7080,6 +7073,18 @@ vectorizable_condition (gimple stmt, gim
>   if (code != COND_EXPR)
>     return false;
> 
>+  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
>+  int nunits = TYPE_VECTOR_SUBPARTS (vectype);
>+
>+  if (slp_node || PURE_SLP_STMT (stmt_info))
>+    ncopies = 1;
>+  else
>+    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
>+
>+  gcc_assert (ncopies >= 1);
>+  if (reduc_index && ncopies > 1)
>+    return false; /* FORNOW */
>+
>   cond_expr = gimple_assign_rhs1 (stmt);
>   then_clause = gimple_assign_rhs2 (stmt);
>   else_clause = gimple_assign_rhs3 (stmt);
>
>
>	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Fri, Jul 03, 2015 at 04:06:26PM +0200, Jakub Jelinek wrote:
> In the pr59984.c testcase, with Marek's patch and this patch, one loop in
> test is already vectorized (the ICE was on the other one), I'll work on
> recognizing multiples of GOMP_SIMD_LANE () as linear next, so that we
> vectorize also the loop with bar.  Without Marek's patch we weren't

And here is a patch to vectorize everything in pr59984.c.
For the purpose of elemental functions, addresses of variables in
simd magic arrays (e.g. private, linear, reduction etc.) are linear,
but they aren't linear in the whole loop, just are linear within the
vectorization factor.

Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

This one really depends on Marek's patch, doesn't make sense to commit
before it goes in.

2015-07-04  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/66718
	* tree-vect-stmts.c (struct simd_call_arg_info): Add simd_lane_linear
	field.
	(vectorizable_simd_clone_call): Support using linear arguments for
	addresses of arrays elements indexed by GOMP_SIMD_LANE result.

--- gcc/tree-vect-stmts.c.jj	2015-07-03 14:06:28.000000000 +0200
+++ gcc/tree-vect-stmts.c	2015-07-03 20:43:42.796573076 +0200
@@ -2618,6 +2618,7 @@ struct simd_call_arg_info
   enum vect_def_type dt;
   HOST_WIDE_INT linear_step;
   unsigned int align;
+  bool simd_lane_linear;
 };
 
 /* Function vectorizable_simd_clone_call.
@@ -2702,6 +2703,7 @@ vectorizable_simd_clone_call (gimple stm
       thisarginfo.linear_step = 0;
       thisarginfo.align = 0;
       thisarginfo.op = NULL_TREE;
+      thisarginfo.simd_lane_linear = false;
 
       op = gimple_call_arg (stmt, i);
       if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
@@ -2724,21 +2726,24 @@ vectorizable_simd_clone_call (gimple stm
 
       /* For linear arguments, the analyze phase should have saved
 	 the base and step in STMT_VINFO_SIMD_CLONE_INFO.  */
-      if (i * 2 + 3 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
-	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2])
+      if (i * 3 + 4 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
+	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2])
 	{
 	  gcc_assert (vec_stmt);
 	  thisarginfo.linear_step
-	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2]);
+	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2]);
 	  thisarginfo.op
-	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 1];
+	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 1];
+	  thisarginfo.simd_lane_linear
+	    = (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 3]
+	       == boolean_true_node);
 	  /* If loop has been peeled for alignment, we need to adjust it.  */
 	  tree n1 = LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo);
 	  tree n2 = LOOP_VINFO_NITERS (loop_vinfo);
-	  if (n1 != n2)
+	  if (n1 != n2 && !thisarginfo.simd_lane_linear)
 	    {
 	      tree bias = fold_build2 (MINUS_EXPR, TREE_TYPE (n1), n1, n2);
-	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2];
+	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2];
 	      tree opt = TREE_TYPE (thisarginfo.op);
 	      bias = fold_convert (TREE_TYPE (step), bias);
 	      bias = fold_build2 (MULT_EXPR, TREE_TYPE (step), bias, step);
@@ -2764,6 +2769,93 @@ vectorizable_simd_clone_call (gimple stm
 		|| thisarginfo.dt == vect_external_def)
 	       && POINTER_TYPE_P (TREE_TYPE (op)))
 	thisarginfo.align = get_pointer_alignment (op) / BITS_PER_UNIT;
+      /* Addresses of array elements indexed by GOMP_SIMD_LANE are
+	 linear too.  */
+      if (POINTER_TYPE_P (TREE_TYPE (op))
+	  && !thisarginfo.linear_step
+	  && !vec_stmt
+	  && thisarginfo.dt != vect_constant_def
+	  && thisarginfo.dt != vect_external_def
+	  && loop_vinfo
+	  && !slp_node
+	  && TREE_CODE (op) == SSA_NAME)
+	{
+	  def_stmt = SSA_NAME_DEF_STMT (op);
+	  if (is_gimple_assign (def_stmt)
+	      && gimple_assign_rhs_code (def_stmt) == POINTER_PLUS_EXPR
+	      && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
+	    {
+	      tree base = gimple_assign_rhs1 (def_stmt);
+	      HOST_WIDE_INT linear_step = 0;
+	      tree v = gimple_assign_rhs2 (def_stmt);
+	      while (v && TREE_CODE (v) == SSA_NAME)
+		{
+		  tree t;
+		  def_stmt = SSA_NAME_DEF_STMT (v);
+		  if (is_gimple_assign (def_stmt))
+		    switch (gimple_assign_rhs_code (def_stmt))
+		      {
+		      case PLUS_EXPR:
+			t = gimple_assign_rhs2 (def_stmt);
+			if (linear_step || TREE_CODE (t) != INTEGER_CST)
+			  {
+			    v = NULL_TREE;
+			    continue;
+			  }
+			base = fold_build2 (POINTER_PLUS_EXPR,
+					    TREE_TYPE (base), base, t);
+			v = gimple_assign_rhs1 (def_stmt);
+			continue;
+		      case MULT_EXPR:
+			t = gimple_assign_rhs2 (def_stmt);
+			if (linear_step
+			    || !tree_fits_shwi_p (t)
+			    || integer_zerop (t))
+			  {
+			    v = NULL_TREE;
+			    continue;
+			  }
+			linear_step = tree_to_shwi (t);
+			v = gimple_assign_rhs1 (def_stmt);
+			continue;
+		      CASE_CONVERT:
+			t = gimple_assign_rhs1 (def_stmt);
+			if (TREE_CODE (TREE_TYPE (t)) != INTEGER_TYPE
+			    || (TYPE_PRECISION (TREE_TYPE (v))
+				< TYPE_PRECISION (TREE_TYPE (t))))
+			  {
+			    v = NULL_TREE;
+			    continue;
+			  }
+			if (!linear_step)
+			  linear_step = 1;
+			v = t;
+			continue;
+		      default:
+			v = NULL_TREE;
+			continue;
+		      }
+		  else if (is_gimple_call (def_stmt)
+			   && gimple_call_internal_p (def_stmt)
+			   && (gimple_call_internal_fn (def_stmt)
+			       == IFN_GOMP_SIMD_LANE)
+			   && loop->simduid
+			   && (TREE_CODE (gimple_call_arg (def_stmt, 0))
+			       == SSA_NAME)
+			   && (SSA_NAME_VAR (gimple_call_arg (def_stmt, 0))
+			       == loop->simduid))
+		    {
+		      if (!linear_step)
+			linear_step = 1;
+		      thisarginfo.linear_step = linear_step;
+		      thisarginfo.op = base;
+		      thisarginfo.simd_lane_linear = true;
+		      v = NULL_TREE;
+		      continue;
+		    }
+		}
+	    }
+	}
 
       arginfo.quick_push (thisarginfo);
     }
@@ -2895,13 +2987,16 @@ vectorizable_simd_clone_call (gimple stm
 	if (bestn->simdclone->args[i].arg_type
 	    == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
 	  {
-	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 2
+	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 3
 									+ 1);
 	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (arginfo[i].op);
 	    tree lst = POINTER_TYPE_P (TREE_TYPE (arginfo[i].op))
 		       ? size_type_node : TREE_TYPE (arginfo[i].op);
 	    tree ls = build_int_cst (lst, arginfo[i].linear_step);
 	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (ls);
+	    tree sll = arginfo[i].simd_lane_linear
+		       ? boolean_true_node : boolean_false_node;
+	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (sll);
 	  }
       STMT_VINFO_TYPE (stmt_info) = call_simd_clone_vec_info_type;
       if (dump_enabled_p ())
@@ -3039,6 +3134,11 @@ vectorizable_simd_clone_call (gimple stm
 		      new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
 		      gcc_assert (!new_bb);
 		    }
+		  if (arginfo[i].simd_lane_linear)
+		    {
+		      vargs.safe_push (arginfo[i].op);
+		      break;
+		    }
 		  tree phi_res = copy_ssa_name (op);
 		  gphi *new_phi = create_phi_node (phi_res, loop->header);
 		  set_vinfo_for_stmt (new_phi,


	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On Sat, 4 Jul 2015, Jakub Jelinek wrote:

> On Fri, Jul 03, 2015 at 04:06:26PM +0200, Jakub Jelinek wrote:
> > In the pr59984.c testcase, with Marek's patch and this patch, one loop in
> > test is already vectorized (the ICE was on the other one), I'll work on
> > recognizing multiples of GOMP_SIMD_LANE () as linear next, so that we
> > vectorize also the loop with bar.  Without Marek's patch we weren't
> 
> And here is a patch to vectorize everything in pr59984.c.
> For the purpose of elemental functions, addresses of variables in
> simd magic arrays (e.g. private, linear, reduction etc.) are linear,
> but they aren't linear in the whole loop, just are linear within the
> vectorization factor.
> 
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
> 
> This one really depends on Marek's patch, doesn't make sense to commit
> before it goes in.
> 
> 2015-07-04  Jakub Jelinek  <jakub@redhat.com>
> 
> 	PR tree-optimization/66718
> 	* tree-vect-stmts.c (struct simd_call_arg_info): Add simd_lane_linear
> 	field.
> 	(vectorizable_simd_clone_call): Support using linear arguments for
> 	addresses of arrays elements indexed by GOMP_SIMD_LANE result.
> 
> --- gcc/tree-vect-stmts.c.jj	2015-07-03 14:06:28.000000000 +0200
> +++ gcc/tree-vect-stmts.c	2015-07-03 20:43:42.796573076 +0200
> @@ -2618,6 +2618,7 @@ struct simd_call_arg_info
>    enum vect_def_type dt;
>    HOST_WIDE_INT linear_step;
>    unsigned int align;
> +  bool simd_lane_linear;
>  };
>  
>  /* Function vectorizable_simd_clone_call.
> @@ -2702,6 +2703,7 @@ vectorizable_simd_clone_call (gimple stm
>        thisarginfo.linear_step = 0;
>        thisarginfo.align = 0;
>        thisarginfo.op = NULL_TREE;
> +      thisarginfo.simd_lane_linear = false;
>  
>        op = gimple_call_arg (stmt, i);
>        if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
> @@ -2724,21 +2726,24 @@ vectorizable_simd_clone_call (gimple stm
>  
>        /* For linear arguments, the analyze phase should have saved
>  	 the base and step in STMT_VINFO_SIMD_CLONE_INFO.  */
> -      if (i * 2 + 3 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
> -	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2])
> +      if (i * 3 + 4 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
> +	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2])
>  	{
>  	  gcc_assert (vec_stmt);
>  	  thisarginfo.linear_step
> -	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2]);
> +	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2]);
>  	  thisarginfo.op
> -	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 1];
> +	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 1];
> +	  thisarginfo.simd_lane_linear
> +	    = (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 3]
> +	       == boolean_true_node);
>  	  /* If loop has been peeled for alignment, we need to adjust it.  */
>  	  tree n1 = LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo);
>  	  tree n2 = LOOP_VINFO_NITERS (loop_vinfo);
> -	  if (n1 != n2)
> +	  if (n1 != n2 && !thisarginfo.simd_lane_linear)
>  	    {
>  	      tree bias = fold_build2 (MINUS_EXPR, TREE_TYPE (n1), n1, n2);
> -	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2];
> +	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2];
>  	      tree opt = TREE_TYPE (thisarginfo.op);
>  	      bias = fold_convert (TREE_TYPE (step), bias);
>  	      bias = fold_build2 (MULT_EXPR, TREE_TYPE (step), bias, step);
> @@ -2764,6 +2769,93 @@ vectorizable_simd_clone_call (gimple stm
>  		|| thisarginfo.dt == vect_external_def)
>  	       && POINTER_TYPE_P (TREE_TYPE (op)))
>  	thisarginfo.align = get_pointer_alignment (op) / BITS_PER_UNIT;
> +      /* Addresses of array elements indexed by GOMP_SIMD_LANE are
> +	 linear too.  */
> +      if (POINTER_TYPE_P (TREE_TYPE (op))
> +	  && !thisarginfo.linear_step
> +	  && !vec_stmt
> +	  && thisarginfo.dt != vect_constant_def
> +	  && thisarginfo.dt != vect_external_def
> +	  && loop_vinfo
> +	  && !slp_node
> +	  && TREE_CODE (op) == SSA_NAME)
> +	{
> +	  def_stmt = SSA_NAME_DEF_STMT (op);
> +	  if (is_gimple_assign (def_stmt)
> +	      && gimple_assign_rhs_code (def_stmt) == POINTER_PLUS_EXPR
> +	      && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
> +	    {
> +	      tree base = gimple_assign_rhs1 (def_stmt);
> +	      HOST_WIDE_INT linear_step = 0;
> +	      tree v = gimple_assign_rhs2 (def_stmt);
> +	      while (v && TREE_CODE (v) == SSA_NAME)

Hmm, this looks like it could be split out to a function.

> +		{
> +		  tree t;
> +		  def_stmt = SSA_NAME_DEF_STMT (v);
> +		  if (is_gimple_assign (def_stmt))
> +		    switch (gimple_assign_rhs_code (def_stmt))
> +		      {
> +		      case PLUS_EXPR:
> +			t = gimple_assign_rhs2 (def_stmt);
> +			if (linear_step || TREE_CODE (t) != INTEGER_CST)
> +			  {
> +			    v = NULL_TREE;
> +			    continue;
> +			  }
> +			base = fold_build2 (POINTER_PLUS_EXPR,
> +					    TREE_TYPE (base), base, t);
> +			v = gimple_assign_rhs1 (def_stmt);
> +			continue;

what about MINUS_EXPR?  I suppose you only handle stuff that's
produced by get_inner_reference here?

> +		      case MULT_EXPR:
> +			t = gimple_assign_rhs2 (def_stmt);
> +			if (linear_step
> +			    || !tree_fits_shwi_p (t)
> +			    || integer_zerop (t))
> +			  {

So no VLAs... (I understand this code is for correctness?)

As I don't know too much about all this OMP stuff the patch is ok
if you split this out to a separate function.

Thanks,
Richard.

> +			    v = NULL_TREE;
> +			    continue;
> +			  }
> +			linear_step = tree_to_shwi (t);
> +			v = gimple_assign_rhs1 (def_stmt);
> +			continue;
> +		      CASE_CONVERT:
> +			t = gimple_assign_rhs1 (def_stmt);
> +			if (TREE_CODE (TREE_TYPE (t)) != INTEGER_TYPE
> +			    || (TYPE_PRECISION (TREE_TYPE (v))
> +				< TYPE_PRECISION (TREE_TYPE (t))))
> +			  {
> +			    v = NULL_TREE;
> +			    continue;
> +			  }
> +			if (!linear_step)
> +			  linear_step = 1;
> +			v = t;
> +			continue;
> +		      default:
> +			v = NULL_TREE;
> +			continue;
> +		      }
> +		  else if (is_gimple_call (def_stmt)
> +			   && gimple_call_internal_p (def_stmt)
> +			   && (gimple_call_internal_fn (def_stmt)
> +			       == IFN_GOMP_SIMD_LANE)
> +			   && loop->simduid
> +			   && (TREE_CODE (gimple_call_arg (def_stmt, 0))
> +			       == SSA_NAME)
> +			   && (SSA_NAME_VAR (gimple_call_arg (def_stmt, 0))
> +			       == loop->simduid))
> +		    {
> +		      if (!linear_step)
> +			linear_step = 1;
> +		      thisarginfo.linear_step = linear_step;
> +		      thisarginfo.op = base;
> +		      thisarginfo.simd_lane_linear = true;
> +		      v = NULL_TREE;
> +		      continue;
> +		    }
> +		}
> +	    }
> +	}
>  
>        arginfo.quick_push (thisarginfo);
>      }
> @@ -2895,13 +2987,16 @@ vectorizable_simd_clone_call (gimple stm
>  	if (bestn->simdclone->args[i].arg_type
>  	    == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
>  	  {
> -	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 2
> +	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 3
>  									+ 1);
>  	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (arginfo[i].op);
>  	    tree lst = POINTER_TYPE_P (TREE_TYPE (arginfo[i].op))
>  		       ? size_type_node : TREE_TYPE (arginfo[i].op);
>  	    tree ls = build_int_cst (lst, arginfo[i].linear_step);
>  	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (ls);
> +	    tree sll = arginfo[i].simd_lane_linear
> +		       ? boolean_true_node : boolean_false_node;
> +	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (sll);
>  	  }
>        STMT_VINFO_TYPE (stmt_info) = call_simd_clone_vec_info_type;
>        if (dump_enabled_p ())
> @@ -3039,6 +3134,11 @@ vectorizable_simd_clone_call (gimple stm
>  		      new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
>  		      gcc_assert (!new_bb);
>  		    }
> +		  if (arginfo[i].simd_lane_linear)
> +		    {
> +		      vargs.safe_push (arginfo[i].op);
> +		      break;
> +		    }
>  		  tree phi_res = copy_ssa_name (op);
>  		  gphi *new_phi = create_phi_node (phi_res, loop->header);
>  		  set_vinfo_for_stmt (new_phi,
> 
> 
> 	Jakub
> 
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Dilip Upmanyu, Graham Norton, HRB 21284 (AG Nuernberg)

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Thu, Jul 09, 2015 at 11:14:01AM +0200, Richard Biener wrote:
> > @@ -2764,6 +2769,93 @@ vectorizable_simd_clone_call (gimple stm
> >  		|| thisarginfo.dt == vect_external_def)
> >  	       && POINTER_TYPE_P (TREE_TYPE (op)))
> >  	thisarginfo.align = get_pointer_alignment (op) / BITS_PER_UNIT;
> > +      /* Addresses of array elements indexed by GOMP_SIMD_LANE are
> > +	 linear too.  */
> > +      if (POINTER_TYPE_P (TREE_TYPE (op))
> > +	  && !thisarginfo.linear_step
> > +	  && !vec_stmt
> > +	  && thisarginfo.dt != vect_constant_def
> > +	  && thisarginfo.dt != vect_external_def
> > +	  && loop_vinfo
> > +	  && !slp_node
> > +	  && TREE_CODE (op) == SSA_NAME)
> > +	{
> > +	  def_stmt = SSA_NAME_DEF_STMT (op);
> > +	  if (is_gimple_assign (def_stmt)
> > +	      && gimple_assign_rhs_code (def_stmt) == POINTER_PLUS_EXPR
> > +	      && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
> > +	    {
> > +	      tree base = gimple_assign_rhs1 (def_stmt);
> > +	      HOST_WIDE_INT linear_step = 0;
> > +	      tree v = gimple_assign_rhs2 (def_stmt);
> > +	      while (v && TREE_CODE (v) == SSA_NAME)
> 
> Hmm, this looks like it could be split out to a function.

Ok, will try that.

> > +			base = fold_build2 (POINTER_PLUS_EXPR,
> > +					    TREE_TYPE (base), base, t);
> > +			v = gimple_assign_rhs1 (def_stmt);
> > +			continue;
> 
> what about MINUS_EXPR?  I suppose you only handle stuff that's
> produced by get_inner_reference here?

This is meant to be used with the "omp simd array" vars, and what
is produced by Marek's pass from those, so something that originally
in the code are simple scalar or aggregate
vars, I'm only handling + with a constant bias, wouldn't subtraction
be folded into addition of negative constant anyway?
This code isn't for correctness, but optimization, if it doesn't detect
something is linear, even when it is, it can simply not be vectorized or
vectorized less efficiently through some other simd clone.
> 
> > +		      case MULT_EXPR:
> > +			t = gimple_assign_rhs2 (def_stmt);
> > +			if (linear_step
> > +			    || !tree_fits_shwi_p (t)
> > +			    || integer_zerop (t))
> > +			  {
> 
> So no VLAs... (I understand this code is for correctness?)

VLAs aren't added as "omp simd array" ever, I punt on them early
(set safelen to 1).

	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Thu, Jul 09, 2015 at 11:21:01AM +0200, Jakub Jelinek wrote:
> > Hmm, this looks like it could be split out to a function.
> 
> Ok, will try that.

Here is what I've committed after another bootstrap/regtest on x86_64-linux
and i686-linux.  You're right, the separate function cleaned stuff up.

2015-07-09  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/66718
	* tree-vect-stmts.c (struct simd_call_arg_info): Add simd_lane_linear
	field.
	(vect_simd_lane_linear): New function.
	(vectorizable_simd_clone_call): Support using linear arguments for
	addresses of arrays elements indexed by GOMP_SIMD_LANE result.

--- gcc/tree-vect-stmts.c.jj	2015-07-08 19:49:26.352199590 +0200
+++ gcc/tree-vect-stmts.c	2015-07-09 18:03:26.206455588 +0200
@@ -2629,8 +2629,79 @@ struct simd_call_arg_info
   enum vect_def_type dt;
   HOST_WIDE_INT linear_step;
   unsigned int align;
+  bool simd_lane_linear;
 };
 
+/* Helper function of vectorizable_simd_clone_call.  If OP, an SSA_NAME,
+   is linear within simd lane (but not within whole loop), note it in
+   *ARGINFO.  */
+
+static void
+vect_simd_lane_linear (tree op, struct loop *loop,
+		       struct simd_call_arg_info *arginfo)
+{
+  gimple def_stmt = SSA_NAME_DEF_STMT (op);
+
+  if (!is_gimple_assign (def_stmt)
+      || gimple_assign_rhs_code (def_stmt) != POINTER_PLUS_EXPR
+      || !is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
+    return;
+
+  tree base = gimple_assign_rhs1 (def_stmt);
+  HOST_WIDE_INT linear_step = 0;
+  tree v = gimple_assign_rhs2 (def_stmt);
+  while (TREE_CODE (v) == SSA_NAME)
+    {
+      tree t;
+      def_stmt = SSA_NAME_DEF_STMT (v);
+      if (is_gimple_assign (def_stmt))
+	switch (gimple_assign_rhs_code (def_stmt))
+	  {
+	  case PLUS_EXPR:
+	    t = gimple_assign_rhs2 (def_stmt);
+	    if (linear_step || TREE_CODE (t) != INTEGER_CST)
+	      return;
+	    base = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (base), base, t);
+	    v = gimple_assign_rhs1 (def_stmt);
+	    continue;
+	  case MULT_EXPR:
+	    t = gimple_assign_rhs2 (def_stmt);
+	    if (linear_step || !tree_fits_shwi_p (t) || integer_zerop (t))
+	      return;
+	    linear_step = tree_to_shwi (t);
+	    v = gimple_assign_rhs1 (def_stmt);
+	    continue;
+	  CASE_CONVERT:
+	    t = gimple_assign_rhs1 (def_stmt);
+	    if (TREE_CODE (TREE_TYPE (t)) != INTEGER_TYPE
+		|| (TYPE_PRECISION (TREE_TYPE (v))
+		    < TYPE_PRECISION (TREE_TYPE (t))))
+	      return;
+	    if (!linear_step)
+	      linear_step = 1;
+	    v = t;
+	    continue;
+	  default:
+	    return;
+	  }
+      else if (is_gimple_call (def_stmt)
+	       && gimple_call_internal_p (def_stmt)
+	       && gimple_call_internal_fn (def_stmt) == IFN_GOMP_SIMD_LANE
+	       && loop->simduid
+	       && TREE_CODE (gimple_call_arg (def_stmt, 0)) == SSA_NAME
+	       && (SSA_NAME_VAR (gimple_call_arg (def_stmt, 0))
+		   == loop->simduid))
+	{
+	  if (!linear_step)
+	    linear_step = 1;
+	  arginfo->linear_step = linear_step;
+	  arginfo->op = base;
+	  arginfo->simd_lane_linear = true;
+	  return;
+	}
+    }
+}
+
 /* Function vectorizable_simd_clone_call.
 
    Check if STMT performs a function call that can be vectorized
@@ -2713,6 +2784,7 @@ vectorizable_simd_clone_call (gimple stm
       thisarginfo.linear_step = 0;
       thisarginfo.align = 0;
       thisarginfo.op = NULL_TREE;
+      thisarginfo.simd_lane_linear = false;
 
       op = gimple_call_arg (stmt, i);
       if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
@@ -2735,21 +2807,24 @@ vectorizable_simd_clone_call (gimple stm
 
       /* For linear arguments, the analyze phase should have saved
 	 the base and step in STMT_VINFO_SIMD_CLONE_INFO.  */
-      if (i * 2 + 3 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
-	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2])
+      if (i * 3 + 4 <= STMT_VINFO_SIMD_CLONE_INFO (stmt_info).length ()
+	  && STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2])
 	{
 	  gcc_assert (vec_stmt);
 	  thisarginfo.linear_step
-	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2]);
+	    = tree_to_shwi (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2]);
 	  thisarginfo.op
-	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 1];
+	    = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 1];
+	  thisarginfo.simd_lane_linear
+	    = (STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 3]
+	       == boolean_true_node);
 	  /* If loop has been peeled for alignment, we need to adjust it.  */
 	  tree n1 = LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo);
 	  tree n2 = LOOP_VINFO_NITERS (loop_vinfo);
-	  if (n1 != n2)
+	  if (n1 != n2 && !thisarginfo.simd_lane_linear)
 	    {
 	      tree bias = fold_build2 (MINUS_EXPR, TREE_TYPE (n1), n1, n2);
-	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 2 + 2];
+	      tree step = STMT_VINFO_SIMD_CLONE_INFO (stmt_info)[i * 3 + 2];
 	      tree opt = TREE_TYPE (thisarginfo.op);
 	      bias = fold_convert (TREE_TYPE (step), bias);
 	      bias = fold_build2 (MULT_EXPR, TREE_TYPE (step), bias, step);
@@ -2775,6 +2850,17 @@ vectorizable_simd_clone_call (gimple stm
 		|| thisarginfo.dt == vect_external_def)
 	       && POINTER_TYPE_P (TREE_TYPE (op)))
 	thisarginfo.align = get_pointer_alignment (op) / BITS_PER_UNIT;
+      /* Addresses of array elements indexed by GOMP_SIMD_LANE are
+	 linear too.  */
+      if (POINTER_TYPE_P (TREE_TYPE (op))
+	  && !thisarginfo.linear_step
+	  && !vec_stmt
+	  && thisarginfo.dt != vect_constant_def
+	  && thisarginfo.dt != vect_external_def
+	  && loop_vinfo
+	  && !slp_node
+	  && TREE_CODE (op) == SSA_NAME)
+	vect_simd_lane_linear (op, loop, &thisarginfo);
 
       arginfo.quick_push (thisarginfo);
     }
@@ -2906,13 +2992,16 @@ vectorizable_simd_clone_call (gimple stm
 	if (bestn->simdclone->args[i].arg_type
 	    == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
 	  {
-	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 2
+	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 3
 									+ 1);
 	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (arginfo[i].op);
 	    tree lst = POINTER_TYPE_P (TREE_TYPE (arginfo[i].op))
 		       ? size_type_node : TREE_TYPE (arginfo[i].op);
 	    tree ls = build_int_cst (lst, arginfo[i].linear_step);
 	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (ls);
+	    tree sll = arginfo[i].simd_lane_linear
+		       ? boolean_true_node : boolean_false_node;
+	    STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (sll);
 	  }
       STMT_VINFO_TYPE (stmt_info) = call_simd_clone_vec_info_type;
       if (dump_enabled_p ())
@@ -3050,6 +3139,11 @@ vectorizable_simd_clone_call (gimple stm
 		      new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
 		      gcc_assert (!new_bb);
 		    }
+		  if (arginfo[i].simd_lane_linear)
+		    {
+		      vargs.safe_push (arginfo[i].op);
+		      break;
+		    }
 		  tree phi_res = copy_ssa_name (op);
 		  gphi *new_phi = create_phi_node (phi_res, loop->header);
 		  set_vinfo_for_stmt (new_phi,

	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Marek Polacek]

On Fri, Jul 03, 2015 at 03:41:29PM +0200, Richard Biener wrote:
> On Fri, 3 Jul 2015, Marek Polacek wrote:
> 
> > This patch implements a new pass, called laddress, which deals with
> > lowering ADDR_EXPR assignments.  Such lowering ought to help the
> > vectorizer, but it also could expose more CSE opportunities, maybe
> > help reassoc, etc.  It's only active when optimize != 0.
> > 
> > So e.g.
> >   _1 = (sizetype) i_9;
> >   _7 = _1 * 4;
> >   _4 = &b + _7;
> > instead of
> >   _4 = &b[i_9];
> > 
> > This triggered 14105 times during the regtest and 6392 times during
> > the bootstrap.
> > 
> > The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> > to a bug in the vectorizer.  Jakub has a patch and knows the details.
> > As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> > (that was the motivation of this pass).
> > 
> > This doesn't introduce any kind of verification nor PROP_laddress.
> > Don't know if we want that, but hopefully it can be done as a follow-up
> > if we do.
> 
> Yes.  At the moment nothing requires lowered address form so this is
> merely an optimization (and not a bug for some later pass to
> re-introduce un-lowered non-invariant addresses).  I can imagine
> that for example IVOPTs could be simplified if we didn't have this
> kind of addresses in the IL.
> 
> > Do we want to move some optimizations into this new pass, e.g.
> > from fwprop?
> 
> I think we might want to re-try forwprop_into_addr_expr before lowering
> the address.  Well, but that's maybe just over-cautionous.
> 
> > Thoughts?
> 
> Please move the pass before crited, crited and pre are supposed to
> go together.

Done.
 
> Otherwise looks ok to me.

I renamed the file to gimple-laddress.c then and adjusted the timevar.
Another change is that for x86_64 we don't need -mavx at all, so I dropped
that.  The test is now restricted to x86_64/i?86; on aarch64/ppc64 we aren't
able to vectorize all the functions.

Bootstrapped/regtested on x86_64-linux + ppc64-linux, ok for trunk?

2015-07-08  Marek Polacek  <polacek@redhat.com>

	PR tree-optimization/66718
	* Makefile.in (OBJS): Add gimple-laddress.o. 
	* passes.def: Schedule pass_laddress.
	* timevar.def (DEFTIMEVAR): Add TV_GIMPLE_LADDRESS.
	* tree-pass.h (make_pass_laddress): Declare.
	* gimple-laddress.c: New file.

	* gcc.dg/vect/vect-126.c: New test.

diff --git gcc/Makefile.in gcc/Makefile.in
index 89eda96..1817025 100644
--- gcc/Makefile.in
+++ gcc/Makefile.in
@@ -1255,6 +1255,7 @@ OBJS = \
 	gimple-expr.o \
 	gimple-iterator.o \
 	gimple-fold.o \
+	gimple-laddress.o \
 	gimple-low.o \
 	gimple-match.o \
 	generic-match.o \
diff --git gcc/gimple-laddress.c gcc/gimple-laddress.c
index e69de29..c8036b9 100644
--- gcc/gimple-laddress.c
+++ gcc/gimple-laddress.c
@@ -0,0 +1,137 @@
+/* Lower and optimize address expressions.
+   Copyright (C) 2015 Free Software Foundation, Inc.
+   Contributed by Marek Polacek <polacek@redhat.com>
+
+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"
+#include "system.h"
+#include "coretypes.h"
+#include "alias.h"
+#include "predict.h"
+#include "tm.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "symtab.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "fold-const.h"
+#include "gimple-expr.h"
+#include "gimple.h"
+#include "gimplify.h"
+#include "gimple-iterator.h"
+#include "gimplify-me.h"
+#include "tree-pass.h"
+
+
+namespace {
+
+const pass_data pass_data_laddress =
+{
+  GIMPLE_PASS, /* type */
+  "laddress", /* name */
+  OPTGROUP_NONE, /* optinfo_flags */
+  TV_GIMPLE_LADDRESS, /* tv_id */
+  ( PROP_cfg | PROP_ssa ), /* properties_required */
+  0, /* properties_provided */
+  0, /* properties_destroyed */
+  0, /* todo_flags_start */
+  0, /* todo_flags_finish */
+};
+
+class pass_laddress : public gimple_opt_pass
+{
+public:
+  pass_laddress (gcc::context *ctxt)
+    : gimple_opt_pass (pass_data_laddress, ctxt)
+  {}
+
+  /* opt_pass methods: */
+  opt_pass * clone () { return new pass_laddress (m_ctxt); }
+  virtual bool gate (function *) { return optimize != 0; }
+  virtual unsigned int execute (function *);
+
+}; // class pass_laddress
+
+unsigned int
+pass_laddress::execute (function *fun)
+{
+  basic_block bb;
+
+  FOR_EACH_BB_FN (bb, fun)
+    {
+      for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
+	{
+	  gimple stmt = gsi_stmt (gsi);
+	  if (!is_gimple_assign (stmt)
+	      || gimple_assign_rhs_code (stmt) != ADDR_EXPR
+	      || is_gimple_invariant_address (gimple_assign_rhs1 (stmt)))
+	    {
+	      gsi_next (&gsi);
+	      continue;
+	    }
+
+	  /* Lower ADDR_EXPR assignments:
+	       _4 = &b[i_9];
+	     into
+	       _1 = (sizetype) i_9;
+	       _7 = _1 * 4;
+	       _4 = &b + _7;
+	     This ought to aid the vectorizer and expose CSE opportunities.
+	  */
+
+	  tree expr = gimple_assign_rhs1 (stmt);
+	  HOST_WIDE_INT bitsize, bitpos;
+	  tree base, offset;
+	  machine_mode mode;
+	  int volatilep = 0, unsignedp = 0;
+	  base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
+				      &bitpos, &offset, &mode, &unsignedp,
+				      &volatilep, false);
+	  gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0);
+	  if (offset != NULL_TREE)
+	    {
+	      if (bitpos != 0)
+		offset = size_binop (PLUS_EXPR, offset,
+				     size_int (bitpos / BITS_PER_UNIT));
+	      offset = force_gimple_operand_gsi (&gsi, offset, true, NULL,
+						 true, GSI_SAME_STMT);
+	      base = build_fold_addr_expr (base);
+	      base = force_gimple_operand_gsi (&gsi, base, true, NULL,
+					       true, GSI_SAME_STMT);
+	      gimple g = gimple_build_assign (gimple_assign_lhs (stmt),
+					      POINTER_PLUS_EXPR, base, offset);
+	      gsi_replace (&gsi, g, false);
+	    }
+	  gsi_next (&gsi);
+	}
+    }
+
+  return 0;
+}
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_laddress (gcc::context *ctxt)
+{
+  return new pass_laddress (ctxt);
+}
diff --git gcc/passes.def gcc/passes.def
index 0d8356b..5cd07ae 100644
--- gcc/passes.def
+++ gcc/passes.def
@@ -213,6 +213,7 @@ along with GCC; see the file COPYING3.  If not see
 	 form if possible.  */
       NEXT_PASS (pass_cse_sincos);
       NEXT_PASS (pass_optimize_bswap);
+      NEXT_PASS (pass_laddress);
       NEXT_PASS (pass_split_crit_edges);
       NEXT_PASS (pass_pre);
       NEXT_PASS (pass_sink_code);
diff --git gcc/testsuite/gcc.dg/vect/vect-126.c gcc/testsuite/gcc.dg/vect/vect-126.c
index e69de29..e269ad3 100644
--- gcc/testsuite/gcc.dg/vect/vect-126.c
+++ gcc/testsuite/gcc.dg/vect/vect-126.c
@@ -0,0 +1,63 @@
+/* PR tree-optimization/66718 */
+/* { dg-do compile } */
+
+int *a[1024], b[1024];
+struct S { int u, v, w, x; };
+struct S c[1024];
+int d[1024][10];
+
+void
+f0 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &b[0];
+}
+
+void
+f1 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    {
+      int *p = &b[0];
+      a[i] = p + i;
+    }
+}
+
+void
+f2 (int *p)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &p[i];
+}
+
+void
+f3 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &b[i];
+}
+
+void
+f4 (void)
+{
+  int *p = &c[0].v;
+  for (int i = 0; i < 1024; i++)
+    a[i] = &p[4 * i];
+}
+
+void
+f5 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    a[i] = &c[i].v;
+}
+
+void
+f6 (void)
+{
+  for (int i = 0; i < 1024; i++)
+    for (unsigned int j = 0; j < 10; j++)
+      a[i] = &d[i][j];
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops in function" 7 "vect" { target { i?86-*-* x86_64-*-* } } } } */
diff --git gcc/timevar.def gcc/timevar.def
index efac4b7..ff22909 100644
--- gcc/timevar.def
+++ gcc/timevar.def
@@ -275,6 +275,7 @@ DEFTIMEVAR (TV_GIMPLE_SLSR           , "straight-line strength reduction")
 DEFTIMEVAR (TV_VTABLE_VERIFICATION   , "vtable verification")
 DEFTIMEVAR (TV_TREE_UBSAN            , "tree ubsan")
 DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
+DEFTIMEVAR (TV_GIMPLE_LADDRESS         , "address lowering")
 
 /* Everything else in rest_of_compilation not included above.  */
 DEFTIMEVAR (TV_EARLY_LOCAL	     , "early local passes")
diff --git gcc/tree-pass.h gcc/tree-pass.h
index 2808dad..c47b22e 100644
--- gcc/tree-pass.h
+++ gcc/tree-pass.h
@@ -393,6 +393,7 @@ extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
 extern unsigned int tail_merge_optimize (unsigned int);
 extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);

	Marek

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Marek Polacek]

On Wed, Jul 08, 2015 at 07:37:41PM +0200, Marek Polacek wrote:
>  DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
> +DEFTIMEVAR (TV_GIMPLE_LADDRESS         , "address lowering")

Consider this whitespace issue fixed.

	Marek

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On Wed, 8 Jul 2015, Marek Polacek wrote:

> On Fri, Jul 03, 2015 at 03:41:29PM +0200, Richard Biener wrote:
> > On Fri, 3 Jul 2015, Marek Polacek wrote:
> > 
> > > This patch implements a new pass, called laddress, which deals with
> > > lowering ADDR_EXPR assignments.  Such lowering ought to help the
> > > vectorizer, but it also could expose more CSE opportunities, maybe
> > > help reassoc, etc.  It's only active when optimize != 0.
> > > 
> > > So e.g.
> > >   _1 = (sizetype) i_9;
> > >   _7 = _1 * 4;
> > >   _4 = &b + _7;
> > > instead of
> > >   _4 = &b[i_9];
> > > 
> > > This triggered 14105 times during the regtest and 6392 times during
> > > the bootstrap.
> > > 
> > > The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> > > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> > > to a bug in the vectorizer.  Jakub has a patch and knows the details.
> > > As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> > > (that was the motivation of this pass).
> > > 
> > > This doesn't introduce any kind of verification nor PROP_laddress.
> > > Don't know if we want that, but hopefully it can be done as a follow-up
> > > if we do.
> > 
> > Yes.  At the moment nothing requires lowered address form so this is
> > merely an optimization (and not a bug for some later pass to
> > re-introduce un-lowered non-invariant addresses).  I can imagine
> > that for example IVOPTs could be simplified if we didn't have this
> > kind of addresses in the IL.
> > 
> > > Do we want to move some optimizations into this new pass, e.g.
> > > from fwprop?
> > 
> > I think we might want to re-try forwprop_into_addr_expr before lowering
> > the address.  Well, but that's maybe just over-cautionous.
> > 
> > > Thoughts?
> > 
> > Please move the pass before crited, crited and pre are supposed to
> > go together.
> 
> Done.
>  
> > Otherwise looks ok to me.
> 
> I renamed the file to gimple-laddress.c then and adjusted the timevar.
> Another change is that for x86_64 we don't need -mavx at all, so I dropped
> that.  The test is now restricted to x86_64/i?86; on aarch64/ppc64 we aren't
> able to vectorize all the functions.
> 
> Bootstrapped/regtested on x86_64-linux + ppc64-linux, ok for trunk?

Ok.

Thanks,
Richard.

> 2015-07-08  Marek Polacek  <polacek@redhat.com>
> 
> 	PR tree-optimization/66718
> 	* Makefile.in (OBJS): Add gimple-laddress.o. 
> 	* passes.def: Schedule pass_laddress.
> 	* timevar.def (DEFTIMEVAR): Add TV_GIMPLE_LADDRESS.
> 	* tree-pass.h (make_pass_laddress): Declare.
> 	* gimple-laddress.c: New file.
> 
> 	* gcc.dg/vect/vect-126.c: New test.
> 
> diff --git gcc/Makefile.in gcc/Makefile.in
> index 89eda96..1817025 100644
> --- gcc/Makefile.in
> +++ gcc/Makefile.in
> @@ -1255,6 +1255,7 @@ OBJS = \
>  	gimple-expr.o \
>  	gimple-iterator.o \
>  	gimple-fold.o \
> +	gimple-laddress.o \
>  	gimple-low.o \
>  	gimple-match.o \
>  	generic-match.o \
> diff --git gcc/gimple-laddress.c gcc/gimple-laddress.c
> index e69de29..c8036b9 100644
> --- gcc/gimple-laddress.c
> +++ gcc/gimple-laddress.c
> @@ -0,0 +1,137 @@
> +/* Lower and optimize address expressions.
> +   Copyright (C) 2015 Free Software Foundation, Inc.
> +   Contributed by Marek Polacek <polacek@redhat.com>
> +
> +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"
> +#include "system.h"
> +#include "coretypes.h"
> +#include "alias.h"
> +#include "predict.h"
> +#include "tm.h"
> +#include "function.h"
> +#include "dominance.h"
> +#include "cfg.h"
> +#include "basic-block.h"
> +#include "tree-ssa-alias.h"
> +#include "symtab.h"
> +#include "tree.h"
> +#include "stringpool.h"
> +#include "tree-ssanames.h"
> +#include "fold-const.h"
> +#include "gimple-expr.h"
> +#include "gimple.h"
> +#include "gimplify.h"
> +#include "gimple-iterator.h"
> +#include "gimplify-me.h"
> +#include "tree-pass.h"
> +
> +
> +namespace {
> +
> +const pass_data pass_data_laddress =
> +{
> +  GIMPLE_PASS, /* type */
> +  "laddress", /* name */
> +  OPTGROUP_NONE, /* optinfo_flags */
> +  TV_GIMPLE_LADDRESS, /* tv_id */
> +  ( PROP_cfg | PROP_ssa ), /* properties_required */
> +  0, /* properties_provided */
> +  0, /* properties_destroyed */
> +  0, /* todo_flags_start */
> +  0, /* todo_flags_finish */
> +};
> +
> +class pass_laddress : public gimple_opt_pass
> +{
> +public:
> +  pass_laddress (gcc::context *ctxt)
> +    : gimple_opt_pass (pass_data_laddress, ctxt)
> +  {}
> +
> +  /* opt_pass methods: */
> +  opt_pass * clone () { return new pass_laddress (m_ctxt); }
> +  virtual bool gate (function *) { return optimize != 0; }
> +  virtual unsigned int execute (function *);
> +
> +}; // class pass_laddress
> +
> +unsigned int
> +pass_laddress::execute (function *fun)
> +{
> +  basic_block bb;
> +
> +  FOR_EACH_BB_FN (bb, fun)
> +    {
> +      for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
> +	{
> +	  gimple stmt = gsi_stmt (gsi);
> +	  if (!is_gimple_assign (stmt)
> +	      || gimple_assign_rhs_code (stmt) != ADDR_EXPR
> +	      || is_gimple_invariant_address (gimple_assign_rhs1 (stmt)))
> +	    {
> +	      gsi_next (&gsi);
> +	      continue;
> +	    }
> +
> +	  /* Lower ADDR_EXPR assignments:
> +	       _4 = &b[i_9];
> +	     into
> +	       _1 = (sizetype) i_9;
> +	       _7 = _1 * 4;
> +	       _4 = &b + _7;
> +	     This ought to aid the vectorizer and expose CSE opportunities.
> +	  */
> +
> +	  tree expr = gimple_assign_rhs1 (stmt);
> +	  HOST_WIDE_INT bitsize, bitpos;
> +	  tree base, offset;
> +	  machine_mode mode;
> +	  int volatilep = 0, unsignedp = 0;
> +	  base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
> +				      &bitpos, &offset, &mode, &unsignedp,
> +				      &volatilep, false);
> +	  gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0);
> +	  if (offset != NULL_TREE)
> +	    {
> +	      if (bitpos != 0)
> +		offset = size_binop (PLUS_EXPR, offset,
> +				     size_int (bitpos / BITS_PER_UNIT));
> +	      offset = force_gimple_operand_gsi (&gsi, offset, true, NULL,
> +						 true, GSI_SAME_STMT);
> +	      base = build_fold_addr_expr (base);
> +	      base = force_gimple_operand_gsi (&gsi, base, true, NULL,
> +					       true, GSI_SAME_STMT);
> +	      gimple g = gimple_build_assign (gimple_assign_lhs (stmt),
> +					      POINTER_PLUS_EXPR, base, offset);
> +	      gsi_replace (&gsi, g, false);
> +	    }
> +	  gsi_next (&gsi);
> +	}
> +    }
> +
> +  return 0;
> +}
> +
> +} // anon namespace
> +
> +gimple_opt_pass *
> +make_pass_laddress (gcc::context *ctxt)
> +{
> +  return new pass_laddress (ctxt);
> +}
> diff --git gcc/passes.def gcc/passes.def
> index 0d8356b..5cd07ae 100644
> --- gcc/passes.def
> +++ gcc/passes.def
> @@ -213,6 +213,7 @@ along with GCC; see the file COPYING3.  If not see
>  	 form if possible.  */
>        NEXT_PASS (pass_cse_sincos);
>        NEXT_PASS (pass_optimize_bswap);
> +      NEXT_PASS (pass_laddress);
>        NEXT_PASS (pass_split_crit_edges);
>        NEXT_PASS (pass_pre);
>        NEXT_PASS (pass_sink_code);
> diff --git gcc/testsuite/gcc.dg/vect/vect-126.c gcc/testsuite/gcc.dg/vect/vect-126.c
> index e69de29..e269ad3 100644
> --- gcc/testsuite/gcc.dg/vect/vect-126.c
> +++ gcc/testsuite/gcc.dg/vect/vect-126.c
> @@ -0,0 +1,63 @@
> +/* PR tree-optimization/66718 */
> +/* { dg-do compile } */
> +
> +int *a[1024], b[1024];
> +struct S { int u, v, w, x; };
> +struct S c[1024];
> +int d[1024][10];
> +
> +void
> +f0 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &b[0];
> +}
> +
> +void
> +f1 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    {
> +      int *p = &b[0];
> +      a[i] = p + i;
> +    }
> +}
> +
> +void
> +f2 (int *p)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &p[i];
> +}
> +
> +void
> +f3 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &b[i];
> +}
> +
> +void
> +f4 (void)
> +{
> +  int *p = &c[0].v;
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &p[4 * i];
> +}
> +
> +void
> +f5 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    a[i] = &c[i].v;
> +}
> +
> +void
> +f6 (void)
> +{
> +  for (int i = 0; i < 1024; i++)
> +    for (unsigned int j = 0; j < 10; j++)
> +      a[i] = &d[i][j];
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops in function" 7 "vect" { target { i?86-*-* x86_64-*-* } } } } */
> diff --git gcc/timevar.def gcc/timevar.def
> index efac4b7..ff22909 100644
> --- gcc/timevar.def
> +++ gcc/timevar.def
> @@ -275,6 +275,7 @@ DEFTIMEVAR (TV_GIMPLE_SLSR           , "straight-line strength reduction")
>  DEFTIMEVAR (TV_VTABLE_VERIFICATION   , "vtable verification")
>  DEFTIMEVAR (TV_TREE_UBSAN            , "tree ubsan")
>  DEFTIMEVAR (TV_INITIALIZE_RTL        , "initialize rtl")
> +DEFTIMEVAR (TV_GIMPLE_LADDRESS         , "address lowering")
>  
>  /* Everything else in rest_of_compilation not included above.  */
>  DEFTIMEVAR (TV_EARLY_LOCAL	     , "early local passes")
> diff --git gcc/tree-pass.h gcc/tree-pass.h
> index 2808dad..c47b22e 100644
> --- gcc/tree-pass.h
> +++ gcc/tree-pass.h
> @@ -393,6 +393,7 @@ extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
> +extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
>  extern unsigned int tail_merge_optimize (unsigned int);
>  extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);
> 
> 	Marek
> 
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Dilip Upmanyu, Graham Norton, HRB 21284 (AG Nuernberg)

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Marek Polacek]

On Thu, Jul 09, 2015 at 10:53:30AM +0200, Richard Biener wrote:
> > I renamed the file to gimple-laddress.c then and adjusted the timevar.
> > Another change is that for x86_64 we don't need -mavx at all, so I dropped
> > that.  The test is now restricted to x86_64/i?86; on aarch64/ppc64 we aren't
> > able to vectorize all the functions.
> > 
> > Bootstrapped/regtested on x86_64-linux + ppc64-linux, ok for trunk?
> 
> Ok.

Thanks, committed.

Jakub, you can proceed with your third patch now ;).

	Marek

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Thu, Jul 09, 2015 at 11:04:38AM +0200, Marek Polacek wrote:
> On Thu, Jul 09, 2015 at 10:53:30AM +0200, Richard Biener wrote:
> > > I renamed the file to gimple-laddress.c then and adjusted the timevar.
> > > Another change is that for x86_64 we don't need -mavx at all, so I dropped
> > > that.  The test is now restricted to x86_64/i?86; on aarch64/ppc64 we aren't
> > > able to vectorize all the functions.
> > > 
> > > Bootstrapped/regtested on x86_64-linux + ppc64-linux, ok for trunk?
> > 
> > Ok.
> 
> Thanks, committed.
> 
> Jakub, you can proceed with your third patch now ;).

That one has not been yet reviewed.
Richard, ping on: http://gcc.gnu.org/ml/gcc-patches/2015-07/msg00251.html

	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Fri, Jul 03, 2015 at 03:21:47PM +0200, Marek Polacek wrote:
> This patch implements a new pass, called laddress, which deals with
> lowering ADDR_EXPR assignments.  Such lowering ought to help the
> vectorizer, but it also could expose more CSE opportunities, maybe
> help reassoc, etc.  It's only active when optimize != 0.
> 
> So e.g.
>   _1 = (sizetype) i_9;
>   _7 = _1 * 4;
>   _4 = &b + _7;
> instead of
>   _4 = &b[i_9];
> 
> This triggered 14105 times during the regtest and 6392 times during
> the bootstrap.
> 
> The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> to a bug in the vectorizer.  Jakub has a patch and knows the details.
> As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> (that was the motivation of this pass).

Just FYI, while bootstrapping/regtesting your patch together with the one
I've posted and another one to vectorize pr59984.c better, I've noticed there
is another regression with your patch (reverting my patches doesn't help,
disabling your gate does help):

+FAIL: libgomp.c/simd-3.c execution test
+FAIL: libgomp.c++/simd-3.C execution test

on both x86_64-linux and i686-linux (at least on AVX capable box).
Most likely hitting another latent vectorizer issue, haven't analyzed it
yet.

	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Jakub Jelinek]

On Sat, Jul 04, 2015 at 09:20:04AM +0200, Jakub Jelinek wrote:
> On Fri, Jul 03, 2015 at 03:21:47PM +0200, Marek Polacek wrote:
> > This patch implements a new pass, called laddress, which deals with
> > lowering ADDR_EXPR assignments.  Such lowering ought to help the
> > vectorizer, but it also could expose more CSE opportunities, maybe
> > help reassoc, etc.  It's only active when optimize != 0.
> > 
> > So e.g.
> >   _1 = (sizetype) i_9;
> >   _7 = _1 * 4;
> >   _4 = &b + _7;
> > instead of
> >   _4 = &b[i_9];
> > 
> > This triggered 14105 times during the regtest and 6392 times during
> > the bootstrap.
> > 
> > The fallout (at least on x86_64) is surprisingly small, i.e. none, just
> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
> > to a bug in the vectorizer.  Jakub has a patch and knows the details.
> > As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
> > (that was the motivation of this pass).
> 
> Just FYI, while bootstrapping/regtesting your patch together with the one
> I've posted and another one to vectorize pr59984.c better, I've noticed there
> is another regression with your patch (reverting my patches doesn't help,
> disabling your gate does help):
> 
> +FAIL: libgomp.c/simd-3.c execution test
> +FAIL: libgomp.c++/simd-3.C execution test
> 
> on both x86_64-linux and i686-linux (at least on AVX capable box).
> Most likely hitting another latent vectorizer issue, haven't analyzed it
> yet.

Here is a fix for that, bootstrapped/regtested on x86_64-linux and
i686-linux on top of Marek's patch and my two other patches, ok for trunk?

The problem was that in loops that don't need any scalar post-loop the
GOMP_SIMD_LAST_LANE value was wrong - 0 instead of vf - 1.

2015-07-04  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/66718
	* tree-vect-stmts.c (vectorizable_call): Replace uses of
	GOMP_SIMD_LANE outside of loop with vf - 1 rather than 0.

--- gcc/tree-vect-stmts.c.jj	2015-07-03 20:43:42.000000000 +0200
+++ gcc/tree-vect-stmts.c	2015-07-04 14:08:18.659356110 +0200
@@ -2601,6 +2601,30 @@ vectorizable_call (gimple gs, gimple_stm
     lhs = gimple_call_lhs (STMT_VINFO_RELATED_STMT (stmt_info));
   else
     lhs = gimple_call_lhs (stmt);
+
+  if (gimple_call_internal_p (stmt)
+      && gimple_call_internal_fn (stmt) == IFN_GOMP_SIMD_LANE)
+    {
+      /* Replace uses of the lhs of GOMP_SIMD_LANE call outside the loop
+	 with vf - 1 rather than 0, that is the last iteration of the
+	 vectorized loop.  */
+      imm_use_iterator iter;
+      use_operand_p use_p;
+      gimple use_stmt;
+      FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
+	{
+	  basic_block use_bb = gimple_bb (use_stmt);
+	  if (use_bb
+	      && !flow_bb_inside_loop_p (LOOP_VINFO_LOOP (loop_vinfo), use_bb))
+	    {
+	      FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
+		SET_USE (use_p, build_int_cst (TREE_TYPE (lhs),
+					       ncopies * nunits_out - 1));
+	      update_stmt (use_stmt);
+	    }
+	}
+    }
+
   new_stmt = gimple_build_assign (lhs, build_zero_cst (type));
   set_vinfo_for_stmt (new_stmt, stmt_info);
   set_vinfo_for_stmt (stmt, NULL);


	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Richard Biener]

On July 4, 2015 4:17:02 PM GMT+02:00, Jakub Jelinek <jakub@redhat.com> wrote:
>On Sat, Jul 04, 2015 at 09:20:04AM +0200, Jakub Jelinek wrote:
>> On Fri, Jul 03, 2015 at 03:21:47PM +0200, Marek Polacek wrote:
>> > This patch implements a new pass, called laddress, which deals with
>> > lowering ADDR_EXPR assignments.  Such lowering ought to help the
>> > vectorizer, but it also could expose more CSE opportunities, maybe
>> > help reassoc, etc.  It's only active when optimize != 0.
>> > 
>> > So e.g.
>> >   _1 = (sizetype) i_9;
>> >   _7 = _1 * 4;
>> >   _4 = &b + _7;
>> > instead of
>> >   _4 = &b[i_9];
>> > 
>> > This triggered 14105 times during the regtest and 6392 times during
>> > the bootstrap.
>> > 
>> > The fallout (at least on x86_64) is surprisingly small, i.e. none,
>just
>> > gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is
>due
>> > to a bug in the vectorizer.  Jakub has a patch and knows the
>details.
>> > As the test shows, we're now able to vectorize ADDR_EXPR of
>non-invariants
>> > (that was the motivation of this pass).
>> 
>> Just FYI, while bootstrapping/regtesting your patch together with the
>one
>> I've posted and another one to vectorize pr59984.c better, I've
>noticed there
>> is another regression with your patch (reverting my patches doesn't
>help,
>> disabling your gate does help):
>> 
>> +FAIL: libgomp.c/simd-3.c execution test
>> +FAIL: libgomp.c++/simd-3.C execution test
>> 
>> on both x86_64-linux and i686-linux (at least on AVX capable box).
>> Most likely hitting another latent vectorizer issue, haven't analyzed
>it
>> yet.
>
>Here is a fix for that, bootstrapped/regtested on x86_64-linux and
>i686-linux on top of Marek's patch and my two other patches, ok for
>trunk?

OK.

Thanks,
Richard.

>The problem was that in loops that don't need any scalar post-loop the
>GOMP_SIMD_LAST_LANE value was wrong - 0 instead of vf - 1.
>
>2015-07-04  Jakub Jelinek  <jakub@redhat.com>
>
>	PR tree-optimization/66718
>	* tree-vect-stmts.c (vectorizable_call): Replace uses of
>	GOMP_SIMD_LANE outside of loop with vf - 1 rather than 0.
>
>--- gcc/tree-vect-stmts.c.jj	2015-07-03 20:43:42.000000000 +0200
>+++ gcc/tree-vect-stmts.c	2015-07-04 14:08:18.659356110 +0200
>@@ -2601,6 +2601,30 @@ vectorizable_call (gimple gs, gimple_stm
>     lhs = gimple_call_lhs (STMT_VINFO_RELATED_STMT (stmt_info));
>   else
>     lhs = gimple_call_lhs (stmt);
>+
>+  if (gimple_call_internal_p (stmt)
>+      && gimple_call_internal_fn (stmt) == IFN_GOMP_SIMD_LANE)
>+    {
>+      /* Replace uses of the lhs of GOMP_SIMD_LANE call outside the
>loop
>+	 with vf - 1 rather than 0, that is the last iteration of the
>+	 vectorized loop.  */
>+      imm_use_iterator iter;
>+      use_operand_p use_p;
>+      gimple use_stmt;
>+      FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
>+	{
>+	  basic_block use_bb = gimple_bb (use_stmt);
>+	  if (use_bb
>+	      && !flow_bb_inside_loop_p (LOOP_VINFO_LOOP (loop_vinfo),
>use_bb))
>+	    {
>+	      FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
>+		SET_USE (use_p, build_int_cst (TREE_TYPE (lhs),
>+					       ncopies * nunits_out - 1));
>+	      update_stmt (use_stmt);
>+	    }
>+	}
>+    }
>+
>   new_stmt = gimple_build_assign (lhs, build_zero_cst (type));
>   set_vinfo_for_stmt (new_stmt, stmt_info);
>   set_vinfo_for_stmt (stmt, NULL);
>
>
>	Jakub

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Bin.Cheng]

[-- Attachment #1: Type: text/plain, Size: 1797 bytes --]

On Sat, Jul 4, 2015 at 3:20 PM, Jakub Jelinek <jakub@redhat.com> wrote:
> On Fri, Jul 03, 2015 at 03:21:47PM +0200, Marek Polacek wrote:
>> This patch implements a new pass, called laddress, which deals with
>> lowering ADDR_EXPR assignments.  Such lowering ought to help the
>> vectorizer, but it also could expose more CSE opportunities, maybe
>> help reassoc, etc.  It's only active when optimize != 0.
>>
>> So e.g.
>>   _1 = (sizetype) i_9;
>>   _7 = _1 * 4;
>>   _4 = &b + _7;
>> instead of
>>   _4 = &b[i_9];
>>
>> This triggered 14105 times during the regtest and 6392 times during
>> the bootstrap.
>>
>> The fallout (at least on x86_64) is surprisingly small, i.e. none, just
>> gcc.dg/vect/pr59984.c test (using -fopenmp-simd) ICEs, but that is due
>> to a bug in the vectorizer.  Jakub has a patch and knows the details.
>> As the test shows, we're now able to vectorize ADDR_EXPR of non-invariants
>> (that was the motivation of this pass).
>
> Just FYI, while bootstrapping/regtesting your patch together with the one
> I've posted and another one to vectorize pr59984.c better, I've noticed there
> is another regression with your patch (reverting my patches doesn't help,
> disabling your gate does help):
>
> +FAIL: libgomp.c/simd-3.c execution test
> +FAIL: libgomp.c++/simd-3.C execution test
>
> on both x86_64-linux and i686-linux (at least on AVX capable box).
> Most likely hitting another latent vectorizer issue, haven't analyzed it
> yet.
Bootstrap and test the patch on aarch64.  Also saw these two failures,
plus below one

FAIL: libgomp.fortran/target6.f90   -Os  execution test

Maybe the same cause with above two.  I will test later with Jakub's patch.

Another problem is the added test failed on aarch64.  I attacked the dump here.

Thanks,
bin
>
>         Jakub

[-- Attachment #2: vect-126.c.133t.vect --]
[-- Type: application/octet-stream, Size: 177211 bytes --]


;; Function f0 (f0, funcdef_no=0, decl_uid=2674, cgraph_uid=0, symbol_order=4)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_8]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: got vectype for stmt: a[i_8] = &b[0];
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: i_8 = PHI <i_5(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand i_8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: def_stmt: i_8 = PHI <i_5(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand i_8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: def_stmt: i_8 = PHI <i_5(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand i_8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: def_stmt: i_8 = PHI <i_5(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: phi relevant? i_8 = PHI <i_5(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: phi relevant? .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: phi relevant? ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: stmt relevant? a[i_8] = &b[0];
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: stmt relevant? i_5 = i_8 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: stmt relevant? ivtmp_6 = ivtmp_1 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: init: stmt relevant? if (ivtmp_6 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: worklist: examine stmt: a[i_8] = &b[0];
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_8] = &b[0];
  stmt_b: a[i_8] = &b[0];
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining phi: i_8 = PHI <i_5(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining phi: .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining phi: ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: a[i_8] = &b[0];

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: i_5 = i_8 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: ivtmp_6 = ivtmp_1 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: if (ivtmp_6 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vectorization factor = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: misalign = 0 bytes of ref a[i_8]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: i_8 = PHI <i_5(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Analyze phi: ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: examining phi: i_8 = PHI <i_5(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: examining phi: .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: examining phi: ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: a[i_8] = &b[0];
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand &b[0]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_model_store_cost: aligned.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_model_store_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: i_5 = i_8 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: irrelevant.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: ivtmp_6 = ivtmp_1 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: irrelevant.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ==> examining statement: if (ivtmp_6 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: irrelevant.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vectorization_factor = 2, niters = 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: cost model disabled.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: loop vectorized
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: === vec_transform_loop ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing phi: i_8 = PHI <i_5(4), 0(6)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing phi: .MEM_9 = PHI <.MEM_4(4), .MEM_3(D)(6)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing phi: ivtmp_1 = PHI <ivtmp_6(4), 1024(6)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing statement: a[i_8] = &b[0];

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: transform statement.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand &b[0]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: transform store. ncopies = 1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_get_vec_def_for_operand: &b[0]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: vect_is_simple_use: operand &b[0]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: def =  &b[0]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: Create vector_inv.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: created new init_stmt: _7 = (long unsigned int) &b[0];
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: created new init_stmt: vect_cst_.9_2 = {_7, _7};
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: create vector_type-pointer variable to type: vector(2) long unsigned int  vectorizing an array ref: a
Applying pattern match.pd:51, generic-match.c:4158
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: created &a
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: add new stmt: MEM[(int * *)vectp_a.10_10] = vect_cst_.9_2;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing statement: i_5 = i_8 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing statement: ivtmp_6 = ivtmp_1 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing statement: vectp_a.10_11 = vectp_a.10_10 + 16;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: ------>vectorizing statement: if (ivtmp_6 != 0)


loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:14: if (ivtmp_13 < 512)

;; Scaling loop 1 with scale 0.500000, bounding iterations to 512 from guessed 98
;; guessed iterations are now 49
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:13:3: note: LOOP VECTORIZED

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:11:1: note: vectorized 1 loops in function.
Merging blocks 2 and 6
fix_loop_structure: fixing up loops for function
f0 ()
{
  vector(2) long unsigned int * vectp_a.11;
  vector(2) long unsigned int * {ref-all} vectp_a.10;
  vector(2) long unsigned int vect_cst_.9;
  int i;
  unsigned int ivtmp_1;
  unsigned int ivtmp_4;
  unsigned int ivtmp_6;
  long unsigned int _7;
  unsigned int ivtmp_13;

  <bb 2>:
  _7 = (long unsigned int) &b[0];
  vect_cst_.9_2 = {_7, _7};

  <bb 3>:
  # i_8 = PHI <i_5(4), 0(2)>
  # ivtmp_1 = PHI <ivtmp_6(4), 1024(2)>
  # vectp_a.10_10 = PHI <vectp_a.10_11(4), &a(2)>
  # ivtmp_4 = PHI <ivtmp_13(4), 0(2)>
  MEM[(int * *)vectp_a.10_10] = vect_cst_.9_2;
  i_5 = i_8 + 1;
  ivtmp_6 = ivtmp_1 - 1;
  vectp_a.10_11 = vectp_a.10_10 + 16;
  ivtmp_13 = ivtmp_4 + 1;
  if (ivtmp_13 < 512)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f1 (f1, funcdef_no=1, decl_uid=2681, cgraph_uid=1, symbol_order=5)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_11]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: got vectype for stmt: a[i_11] = _6;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: i_11 = PHI <i_8(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: .MEM_12 = PHI <.MEM_7(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: phi relevant? i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: phi relevant? .MEM_12 = PHI <.MEM_7(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: phi relevant? ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? _6 = &b[0] + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? a[i_11] = _6;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? i_8 = i_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? ivtmp_1 = ivtmp_9 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: init: stmt relevant? if (ivtmp_1 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: a[i_11] = _6;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand _6
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: _6 = &b[0] + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: _6 = &b[0] + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand _5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_8 = i_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: worklist: examine stmt: i_8 = i_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_11] = _6;
  stmt_b: a[i_11] = _6;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining phi: i_11 = PHI <i_8(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining phi: .MEM_12 = PHI <.MEM_7(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining phi: ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: _4 = (long unsigned int) i_11;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: _5 = _4 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: _6 = &b[0] + _5;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: a[i_11] = _6;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: i_8 = i_11 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: ivtmp_1 = ivtmp_9 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: if (ivtmp_1 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: misalign = 0 bytes of ref a[i_11]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: i_11 = PHI <i_8(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: .MEM_12 = PHI <.MEM_7(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: Analyze phi: ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: examining phi: i_11 = PHI <i_8(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: examining phi: .MEM_12 = PHI <.MEM_7(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: examining phi: ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand i_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: i_11 = PHI <i_8(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ==> examining statement: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: def_stmt: _4 = (long unsigned int) i_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: not vectorized: relevant stmt not supported: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_11]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: not vectorized: no vectype for stmt: a[i_11] = _6;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:20:3: note: bad data references.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:18:1: note: vectorized 0 loops in function.
f1 ()
{
  int i;
  unsigned int ivtmp_1;
  long unsigned int _4;
  long unsigned int _5;
  int * _6;
  unsigned int ivtmp_9;

  <bb 2>:

  <bb 3>:
  # i_11 = PHI <i_8(4), 0(2)>
  # ivtmp_9 = PHI <ivtmp_1(4), 1024(2)>
  _4 = (long unsigned int) i_11;
  _5 = _4 * 4;
  _6 = &b[0] + _5;
  a[i_11] = _6;
  i_8 = i_11 + 1;
  ivtmp_1 = ivtmp_9 - 1;
  if (ivtmp_1 != 0)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f2 (f2, funcdef_no=2, decl_uid=2689, cgraph_uid=2, symbol_order=6)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_12]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: got vectype for stmt: a[i_12] = _7;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: phi relevant? i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: phi relevant? .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: phi relevant? ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? _7 = p_6(D) + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? a[i_12] = _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? ivtmp_1 = ivtmp_10 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: init: stmt relevant? if (ivtmp_1 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: a[i_12] = _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: _7 = p_6(D) + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: _7 = p_6(D) + _5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand p_6(D)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand _5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: worklist: examine stmt: i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_12] = _7;
  stmt_b: a[i_12] = _7;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining phi: ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: _4 = (long unsigned int) i_12;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: _5 = _4 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: _7 = p_6(D) + _5;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: a[i_12] = _7;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: i_9 = i_12 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: ivtmp_1 = ivtmp_10 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: if (ivtmp_1 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: misalign = 0 bytes of ref a[i_12]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: Analyze phi: ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: examining phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: examining phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: examining phi: ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ==> examining statement: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: def_stmt: _4 = (long unsigned int) i_12;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: not vectorized: relevant stmt not supported: _5 = _4 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_12]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: not vectorized: no vectype for stmt: a[i_12] = _7;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:30:3: note: bad data references.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:28:1: note: vectorized 0 loops in function.
f2 (int * p)
{
  int i;
  unsigned int ivtmp_1;
  long unsigned int _4;
  long unsigned int _5;
  int * _7;
  unsigned int ivtmp_10;

  <bb 2>:

  <bb 3>:
  # i_12 = PHI <i_9(4), 0(2)>
  # ivtmp_10 = PHI <ivtmp_1(4), 1024(2)>
  _4 = (long unsigned int) i_12;
  _5 = _4 * 4;
  _7 = p_6(D) + _5;
  a[i_12] = _7;
  i_9 = i_12 + 1;
  ivtmp_1 = ivtmp_10 - 1;
  if (ivtmp_1 != 0)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f3 (f3, funcdef_no=3, decl_uid=2696, cgraph_uid=3, symbol_order=7)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_9]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: got vectype for stmt: a[i_9] = _4;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: phi relevant? i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: phi relevant? .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: phi relevant? ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? _7 = _1 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? _4 = &b + _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? a[i_9] = _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? ivtmp_2 = ivtmp_8 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: init: stmt relevant? if (ivtmp_2 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: a[i_9] = _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: _4 = &b + _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: _4 = &b + _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: _7 = _1 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: _7 = _1 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_6
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: worklist: examine stmt: i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_9] = _4;
  stmt_b: a[i_9] = _4;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining phi: ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: _1 = (sizetype) i_9;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: _7 = _1 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: _4 = &b + _7;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int[1024] *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: a[i_9] = _4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: i_6 = i_9 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: ivtmp_2 = ivtmp_8 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: if (ivtmp_2 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: misalign = 0 bytes of ref a[i_9]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: Analyze phi: ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: examining phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: examining phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: examining phi: ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ==> examining statement: _7 = _1 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: not vectorized: relevant stmt not supported: _7 = _1 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_9]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: not vectorized: no vectype for stmt: a[i_9] = _4;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:37:3: note: bad data references.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:35:1: note: vectorized 0 loops in function.
f3 ()
{
  int i;
  sizetype _1;
  unsigned int ivtmp_2;
  int * _4;
  sizetype _7;
  unsigned int ivtmp_8;

  <bb 2>:

  <bb 3>:
  # i_9 = PHI <i_6(4), 0(2)>
  # ivtmp_8 = PHI <ivtmp_2(4), 1024(2)>
  _1 = (sizetype) i_9;
  _7 = _1 * 4;
  _4 = &b + _7;
  a[i_9] = _4;
  i_6 = i_9 + 1;
  ivtmp_2 = ivtmp_8 - 1;
  if (ivtmp_2 != 0)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f4 (f4, funcdef_no=4, decl_uid=2703, cgraph_uid=4, symbol_order=8)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_12]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: got vectype for stmt: a[i_12] = _7;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: phi relevant? i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: phi relevant? .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: phi relevant? ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? _6 = _5 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? _7 = &c[0].v + _6;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? a[i_12] = _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? ivtmp_10 = ivtmp_11 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: init: stmt relevant? if (ivtmp_10 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: a[i_12] = _7;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _7 = &c[0].v + _6;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: _7 = &c[0].v + _6;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _6
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _6 = _5 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: _6 = _5 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: worklist: examine stmt: i_9 = i_12 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_12] = _7;
  stmt_b: a[i_12] = _7;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining phi: ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _4 = i_12 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _5 = (long unsigned int) _4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _6 = _5 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _7 = &c[0].v + _6;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: a[i_12] = _7;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: i_9 = i_12 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: ivtmp_10 = ivtmp_11 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: if (ivtmp_10 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: misalign = 0 bytes of ref a[i_12]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: Analyze phi: ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: examining phi: i_12 = PHI <i_9(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: examining phi: .MEM_13 = PHI <.MEM_8(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: examining phi: ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand i_12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: i_12 = PHI <i_9(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vectorizable_operation ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_model_simple_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _4 = i_12 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ==> examining statement: _6 = _5 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand _5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: def_stmt: _5 = (long unsigned int) _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: vect_is_simple_use: operand 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: not vectorized: relevant stmt not supported: _6 = _5 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_12]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: not vectorized: no vectype for stmt: a[i_12] = _7;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:45:3: note: bad data references.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:42:1: note: vectorized 0 loops in function.
f4 ()
{
  int i;
  int _4;
  long unsigned int _5;
  long unsigned int _6;
  int * _7;
  unsigned int ivtmp_10;
  unsigned int ivtmp_11;

  <bb 2>:

  <bb 3>:
  # i_12 = PHI <i_9(4), 0(2)>
  # ivtmp_11 = PHI <ivtmp_10(4), 1024(2)>
  _4 = i_12 * 4;
  _5 = (long unsigned int) _4;
  _6 = _5 * 4;
  _7 = &c[0].v + _6;
  a[i_12] = _7;
  i_9 = i_12 + 1;
  ivtmp_10 = ivtmp_11 - 1;
  if (ivtmp_10 != 0)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f5 (f5, funcdef_no=5, decl_uid=2711, cgraph_uid=5, symbol_order=9)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_9]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: got vectype for stmt: a[i_9] = _4;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand 16
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: phi relevant? i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: phi relevant? .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: phi relevant? ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? _8 = _7 + 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? _4 = &c + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? a[i_9] = _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? ivtmp_11 = ivtmp_12 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: init: stmt relevant? if (ivtmp_11 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: a[i_9] = _4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _4 = &c + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: _4 = &c + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _8 = _7 + 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: _8 = _7 + 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _7
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_6
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: worklist: examine stmt: i_6 = i_9 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_9] = _4;
  stmt_b: a[i_9] = _4;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining phi: ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _1 = (sizetype) i_9;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _7 = _1 * 16;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _8 = _7 + 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _4 = &c + _8;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  struct S[1024] *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: a[i_9] = _4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: i_6 = i_9 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: ivtmp_11 = ivtmp_12 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: if (ivtmp_11 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: misalign = 0 bytes of ref a[i_9]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: Analyze phi: ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: examining phi: i_9 = PHI <i_6(4), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: examining phi: .MEM_10 = PHI <.MEM_5(4), .MEM_3(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: examining phi: ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand i_9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: i_9 = PHI <i_6(4), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ==> examining statement: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand _1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: def_stmt: _1 = (sizetype) i_9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: vect_is_simple_use: operand 16
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: not vectorized: relevant stmt not supported: _7 = _1 * 16;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_9]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: not vectorized: no vectype for stmt: a[i_9] = _4;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:52:3: note: bad data references.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:50:1: note: vectorized 0 loops in function.
f5 ()
{
  int i;
  sizetype _1;
  int * _4;
  sizetype _7;
  sizetype _8;
  unsigned int ivtmp_11;
  unsigned int ivtmp_12;

  <bb 2>:

  <bb 3>:
  # i_9 = PHI <i_6(4), 0(2)>
  # ivtmp_12 = PHI <ivtmp_11(4), 1024(2)>
  _1 = (sizetype) i_9;
  _7 = _1 * 16;
  _8 = _7 + 4;
  _4 = &c + _8;
  a[i_9] = _4;
  i_6 = i_9 + 1;
  ivtmp_11 = ivtmp_12 - 1;
  if (ivtmp_11 != 0)
    goto <bb 4>;
  else
    goto <bb 5>;

  <bb 4>:
  goto <bb 3>;

  <bb 5>:
  return;

}



;; Function f6 (f6, funcdef_no=6, decl_uid=2718, cgraph_uid=6, symbol_order=10)


Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ===== analyze_loop_nest_1 =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 2
  exit condition [9, + , 4294967295] != 0
  bounds on difference of bases: -9 ... -9
  result:
    # of iterations 9, bounded by 9
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Considering outer-loop vectorization.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === get_loop_niters ===
Analyzing # of iterations of loop 1
  exit condition [1023, + , 4294967295] != 0
  bounds on difference of bases: -1023 ... -1023
  result:
    # of iterations 1023, bounded by 1023
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_5]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: got vectype for stmt: a[i_5] = a_I_lsm.83_13;
vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: i_5 = PHI <i_10(6), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Access function of PHI: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: .MEM_17 = PHI <.MEM_19(6), .MEM_6(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Access function of PHI: {1024, +, 4294967295}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: step: 4294967295,  init: 1024
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Access function of PHI: {0, +, 1}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Access function of PHI: {10, +, 4294967295}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: step: 4294967295,  init: 10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_30
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand 10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand _14
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_31
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_31
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_30
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_31
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand _23
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: _23 = pretmp_31 + 9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? .MEM_17 = PHI <.MEM_19(6), .MEM_6(D)(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: phi relevant? ivtmp_22 = PHI <ivtmp_21(3), 10(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _15 = _14 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _7 = &d + _15;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? j_9 = j_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? ivtmp_21 = ivtmp_22 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? if (ivtmp_21 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _23 = pretmp_31 + 9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? _8 = _23 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? a_I_lsm.83_13 = &d + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? a[i_5] = a_I_lsm.83_13;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vec_stmt_relevant_p: stmt has vdefs.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? i_10 = i_5 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? ivtmp_18 = ivtmp_20 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: init: stmt relevant? if (ivtmp_18 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: a[i_5] = a_I_lsm.83_13;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand a_I_lsm.83_13
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: a_I_lsm.83_13 = &d + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: a_I_lsm.83_13 = &d + _8;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand _8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: _8 = _23 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: _8 = _23 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand _23
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: _23 = pretmp_31 + 9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: _23 = pretmp_31 + 9;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_31
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_30
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_10 = i_5 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: worklist: examine stmt: i_10 = i_5 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: mark relevant 4, live 0.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: already marked relevant/live.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_data_ref_dependences ===
(compute_affine_dependence
  stmt_a: a[i_5] = a_I_lsm.83_13;
  stmt_b: a[i_5] = a_I_lsm.83_13;
(analyze_overlapping_iterations 
  (chrec_a = {0, +, 1}_1)
  (chrec_b = {0, +, 1}_1)
  (overlap_iterations_a = [0])
  (overlap_iterations_b = [0]))
)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: i_5 = PHI <i_10(6), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: .MEM_17 = PHI <.MEM_19(6), .MEM_6(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: pretmp_30 = (sizetype) i_5;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: pretmp_31 = pretmp_30 * 10;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _12 = (sizetype) j_11;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _14 = _12 + pretmp_31;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _15 = _14 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _7 = &d + _15;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: j_9 = j_11 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: ivtmp_21 = ivtmp_22 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: if (ivtmp_21 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _23 = pretmp_31 + 9;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: _8 = _23 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) sizetype
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: a_I_lsm.83_13 = &d + _8;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int[1024][10] *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: a[i_5] = a_I_lsm.83_13;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(2) long unsigned int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: i_10 = i_5 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: get vectype for scalar type:  int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectype: vector(4) int
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: nunits = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: ivtmp_18 = ivtmp_20 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: if (ivtmp_18 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vectorization factor = 4
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_slp ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_make_slp_decision ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_compute_data_ref_alignment:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: misalign = 0 bytes of ref a[i_5]
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_prune_runtime_alias_test_list ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_enhance_data_refs_alignment ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_can_advance_ivs_p:
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: i_5 = PHI <i_10(6), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: .MEM_17 = PHI <.MEM_19(6), .MEM_6(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: virtual phi. skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Analyze phi: ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_loop_operations ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: examining phi: i_5 = PHI <i_10(6), 0(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vectorizable_induction ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_model_induction_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: examining phi: .MEM_17 = PHI <.MEM_19(6), .MEM_6(D)(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: examining phi: ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand i_5
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: i_5 = PHI <i_10(6), 0(2)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vectorizable_conversion ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_model_promotion_demotion_cost: inside_cost = 0, prologue_cost = 0 .
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ==> examining statement: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand pretmp_30
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: def_stmt: pretmp_30 = (sizetype) i_5;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: vect_is_simple_use: operand 10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: op not supported by target.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: not vectorized: relevant stmt not supported: pretmp_31 = pretmp_30 * 10;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: bad operation or unsupported loop bound.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: ===== analyze_loop_nest_1 =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: Considering outer-loop vectorization.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: === vect_analyze_data_refs ===
Creating dr for a[i_5]
analyze_innermost: Applying pattern match.pd:51, generic-match.c:3274
success.
	base_address: &a
	offset from base address: 0
	constant offset from base address: 0
	step: 8
	aligned to: 128
	base_object: a
	Access function 0: {0, +, 1}_1
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: not vectorized: no vectype for stmt: a[i_5] = a_I_lsm.83_13;
 scalar_type: int *
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:59:3: note: bad data references.

Analyzing loop at /root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ===== analyze_loop_nest =====
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_refs ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Access function of PHI: {0, +, 1}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Access function of PHI: {10, +, 4294967295}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: step: 4294967295,  init: 10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_recog_widen_sum_pattern: detected: patt_4 = j_11 w+ pretmp_31;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _14
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? ivtmp_22 = PHI <ivtmp_21(3), 10(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _15 = _14 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _7 = &d + _15;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? j_9 = j_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? ivtmp_21 = ivtmp_22 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? if (ivtmp_21 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_ref_dependences ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _12 = (sizetype) j_11;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _14 = _12 + pretmp_31;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _15 = _14 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _7 = &d + _15;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: j_9 = j_11 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: ivtmp_21 = ivtmp_22 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: if (ivtmp_21 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vectorization factor = 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: not vectorized: unsupported data-type
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: can't determine vectorization factor.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ***** Re-trying analysis with vector size 8
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_loop_form ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === get_loop_niters ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_refs ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_scalar_cycles ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Access function of PHI: {0, +, 1}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: step: 1,  init: 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Analyze phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Access function of PHI: {10, +, 4294967295}_2
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: step: 4294967295,  init: 10
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: Detected induction.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_pattern_recog ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_recog_widen_sum_pattern: detected: patt_3 = j_11 w+ pretmp_31;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _12
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand _14
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: internal
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vect_is_simple_use: operand j_11
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: def_stmt: j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: type of def: induction
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_ref_accesses ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_mark_stmts_to_be_vectorized ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? j_11 = PHI <j_9(3), 0(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: phi relevant? ivtmp_22 = PHI <ivtmp_21(3), 10(7)>
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _12 = (sizetype) j_11;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _14 = _12 + pretmp_31;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _15 = _14 * 4;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? _7 = &d + _15;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? j_9 = j_11 + 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? ivtmp_21 = ivtmp_22 - 1;
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: init: stmt relevant? if (ivtmp_21 != 0)
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_analyze_data_ref_dependences ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: === vect_determine_vectorization_factor ===
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: j_11 = PHI <j_9(3), 0(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: .MEM_16 = PHI <.MEM_16(3), .MEM_17(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining phi: ivtmp_22 = PHI <ivtmp_21(3), 10(7)>

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _12 = (sizetype) j_11;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _14 = _12 + pretmp_31;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _15 = _14 * 4;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: _7 = &d + _15;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: j_9 = j_11 + 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: ivtmp_21 = ivtmp_22 - 1;

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: ==> examining statement: if (ivtmp_21 != 0)

/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: skip.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: vectorization factor = 0
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: not vectorized: unsupported data-type
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:60:5: note: can't determine vectorization factor.
/root/work/gcc-patches/trunk-patch/gcc/gcc/testsuite/gcc.dg/vect/vect-126.c:57:1: note: vectorized 0 loops in function.
f6 ()
{
  _Bool a_I_lsm.84;
  int * a_I_lsm.83;
  unsigned int j;
  int i;
  sizetype patt_3;
  sizetype patt_4;
  int * _7;
  sizetype _8;
  sizetype _12;
  sizetype _14;
  sizetype _15;
  unsigned int ivtmp_18;
  unsigned int ivtmp_20;
  unsigned int ivtmp_21;
  unsigned int ivtmp_22;
  sizetype _23;
  sizetype pretmp_30;
  sizetype pretmp_31;

  <bb 2>:
  goto <bb 7>;

  <bb 3>:

  <bb 4>:
  # j_11 = PHI <j_9(3), 0(7)>
  # ivtmp_22 = PHI <ivtmp_21(3), 10(7)>
  _12 = (sizetype) j_11;
  _14 = _12 + pretmp_31;
  _15 = _14 * 4;
  _7 = &d + _15;
  j_9 = j_11 + 1;
  ivtmp_21 = ivtmp_22 - 1;
  if (ivtmp_21 != 0)
    goto <bb 3>;
  else
    goto <bb 5>;

  <bb 5>:
  _23 = pretmp_31 + 9;
  _8 = _23 * 4;
  a_I_lsm.83_13 = &d + _8;
  a[i_5] = a_I_lsm.83_13;
  i_10 = i_5 + 1;
  ivtmp_18 = ivtmp_20 - 1;
  if (ivtmp_18 != 0)
    goto <bb 6>;
  else
    goto <bb 8>;

  <bb 6>:

  <bb 7>:
  # i_5 = PHI <i_10(6), 0(2)>
  # ivtmp_20 = PHI <ivtmp_18(6), 1024(2)>
  pretmp_30 = (sizetype) i_5;
  pretmp_31 = pretmp_30 * 10;
  goto <bb 4>;

  <bb 8>:
  return;

}

Re: RFC: Add ADDR_EXPR lowering (PR tree-optimization/66718)

[Marek Polacek]

On Sun, Jul 05, 2015 at 11:10:14AM +0800, Bin.Cheng wrote:
> > Just FYI, while bootstrapping/regtesting your patch together with the one
> > I've posted and another one to vectorize pr59984.c better, I've noticed there
> > is another regression with your patch (reverting my patches doesn't help,
> > disabling your gate does help):
> >
> > +FAIL: libgomp.c/simd-3.c execution test
> > +FAIL: libgomp.c++/simd-3.C execution test
> >
> > on both x86_64-linux and i686-linux (at least on AVX capable box).
> > Most likely hitting another latent vectorizer issue, haven't analyzed it
> > yet.
> Bootstrap and test the patch on aarch64.  Also saw these two failures,
> plus below one

Thanks for testing.

> FAIL: libgomp.fortran/target6.f90   -Os  execution test
> 
> Maybe the same cause with above two.  I will test later with Jakub's patch.

I suppose these are fixed now.
 
> Another problem is the added test failed on aarch64.  I attacked the dump here.

That's because on aarch64 we aren't able to vectorize as much as on x86_64.
I'll post a new version of the patch in a bit with the test restricted to
x86_64/i?86.

	Marek