path: root/gcc/tree-ssa-loop-ch.cc

/* Loop header copying on trees.
   Copyright (C) 2004-2024 Free Software Foundation, Inc.

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/>.  */

#define INCLUDE_MEMORY
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "cfghooks.h"
#include "tree-pass.h"
#include "gimple-ssa.h"
#include "gimple-iterator.h"
#include "tree-cfg.h"
#include "tree-into-ssa.h"
#include "cfgloop.h"
#include "tree-inline.h"
#include "tree-ssa-threadedge.h"
#include "tree-ssa-sccvn.h"
#include "tree-phinodes.h"
#include "ssa-iterators.h"
#include "value-range.h"
#include "gimple-range.h"
#include "gimple-range-path.h"
#include "gimple-pretty-print.h"
#include "cfganal.h"
#include "tree-ssa-loop-manip.h"
#include "tree-ssa-loop-niter.h"
#include "tree-scalar-evolution.h"

/* Return path query insteance for testing ranges of statements
   in headers of LOOP contained in basic block BB.
   Use RANGER instance.  */

static path_range_query *
get_range_query (class loop *loop,
		 basic_block bb,
		 gimple_ranger &ranger)
{
  auto_vec<basic_block, 8> path;
  for (; bb != loop->header; bb = single_pred_edge (bb)->src)
    path.safe_push (bb);
  path.safe_push (loop->header);
  path.safe_push (loop_preheader_edge (loop)->src);
  return new path_range_query (ranger, path);
}

/* Return edge that is true in the first iteration of the loop
   and NULL otherwise.
   Formulate corrent ranger query to RANGER.  */

static edge
static_loop_exit (class loop *l, basic_block bb, gimple_ranger &ranger,
		  path_range_query *&query)
{
  gcond *last = safe_dyn_cast <gcond *> (*gsi_last_bb (bb));
  edge ret_e;

  if (!last)
    return NULL;

  edge true_e, false_e;
  extract_true_false_edges_from_block (bb, &true_e, &false_e);

  /* If neither edge is the exit edge, this is not a case we'd like to
     special-case.  */
  if (!loop_exit_edge_p (l, true_e) && !loop_exit_edge_p (l, false_e))
    return NULL;

  int_range<1> desired_static_range;
  if (loop_exit_edge_p (l, true_e))
    {
      desired_static_range = range_false ();
      ret_e = true_e;
    }
  else
   {
      desired_static_range = range_true ();
      ret_e = false_e;
   }

  if (!query)
    query = get_range_query (l, gimple_bb (last), ranger);

  int_range<2> r;
  if (!query->range_of_stmt (r, last))
    return NULL;
  return r == desired_static_range ? ret_e : NULL;
}

/* Return true if STMT is static in LOOP.  This means that its value
   is constant in the first iteration.
   Use RANGER and formulate query cached in QUERY.  */

static bool
loop_static_stmt_p (class loop *loop,
		    gimple_ranger &ranger,
		    path_range_query *&query,
		    gimple *stmt)
{
  tree type = gimple_range_type (stmt);
  if (!type || !value_range::supports_type_p (type))
    return false;

  if (!query)
    query = get_range_query (loop, gimple_bb (stmt), ranger);

  value_range r (gimple_range_type (stmt));
  if (!query->range_of_stmt (r, stmt))
    return false;
  return r.singleton_p ();
}

/* Return true if OP is invariant.  */

static bool
loop_invariant_op_p (class loop *loop,
		     tree op)
{
  if (is_gimple_min_invariant (op))
    return true;
  if (SSA_NAME_IS_DEFAULT_DEF (op)
      || !flow_bb_inside_loop_p (loop, gimple_bb (SSA_NAME_DEF_STMT (op))))
    return true;
  return gimple_uid (SSA_NAME_DEF_STMT (op)) & 1;
}

/* Return true if OP combines outcome of static and
   loop invariant conditional.  */

static bool
loop_static_op_p (class loop *loop, tree op)
{
  /* Always check for invariant first.  */
  gcc_checking_assert (!is_gimple_min_invariant (op)
		       && !SSA_NAME_IS_DEFAULT_DEF (op)
		       && flow_bb_inside_loop_p (loop,
			       gimple_bb (SSA_NAME_DEF_STMT (op))));
  return gimple_uid (SSA_NAME_DEF_STMT (op)) & 2;
}


/* Return true if OP combines outcome of static and
   loop invariant conditional.  */

static bool
loop_combined_static_and_iv_p (class loop *loop,
			       tree op)
{
  /* Always check for invariant first.  */
  gcc_checking_assert (!is_gimple_min_invariant (op)
		       && !SSA_NAME_IS_DEFAULT_DEF (op)
		       && flow_bb_inside_loop_p (loop,
			       gimple_bb (SSA_NAME_DEF_STMT (op))));
  return gimple_uid (SSA_NAME_DEF_STMT (op)) & 4;
}

/* Decision about posibility of copying a given header.  */

enum ch_decision
{
  /* We do not want to copy this header.  */
  ch_impossible,
  /* We can copy it if it enables wins.  */
  ch_possible,
  /* We can "copy" it if it enables wins and doing
     so will introduce no new code.  */
  ch_possible_zero_cost,
  /* We want to copy.  */
  ch_win,
  /* We want to copy and we will eliminate loop exit.  */
  ch_win_invariant_exit
};

/* Check whether we should duplicate HEADER of LOOP.  At most *LIMIT
   instructions should be duplicated, limit is decreased by the actual
   amount.  */

static ch_decision
should_duplicate_loop_header_p (basic_block header, class loop *loop,
				gimple_ranger *ranger,
				int *limit,
				hash_set <edge> *invariant_exits,
				hash_set <edge> *static_exits)
{
  gimple_stmt_iterator bsi;

  gcc_assert (!header->aux);

  gcc_assert (EDGE_COUNT (header->succs) > 0);
  if (single_succ_p (header))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Not duplicating bb %i: it is single succ.\n",
		 header->index);
      return ch_impossible;
    }

  if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest)
      && flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 1)->dest))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Not duplicating bb %i: both successors are in loop.\n",
		 loop->num);
      return ch_impossible;
    }

  /* If this is not the original loop header, we want it to have just
     one predecessor in order to match the && pattern.  */
  if (header != loop->header && !single_pred_p (header))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Not duplicating bb %i: it has mutiple predecestors.\n",
		 header->index);
      return ch_impossible;
    }

  gcond *last = safe_dyn_cast <gcond *> (*gsi_last_bb (header));
  if (!last)
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Not duplicating bb %i: it does not end by conditional.\n",
		 header->index);
      return ch_impossible;
    }

  path_range_query *query = NULL;
  for (gphi_iterator psi = gsi_start_phis (header); !gsi_end_p (psi);
       gsi_next (&psi))
    if (!virtual_operand_p (gimple_phi_result (psi.phi ())))
      {
	bool static_p = loop_static_stmt_p (loop, *ranger,
					    query, psi.phi ());
	gimple_set_uid (psi.phi (), static_p ? 2 : 0);
      }
  bool code_size_cost = false;

  /* Count number of instructions and punt on calls.
     Populate stmts INV flag to later apply heuristics to the
     kind of conditions we want to copy.  */
  for (bsi = gsi_start_bb (header); !gsi_end_p (bsi); gsi_next (&bsi))
    {
      gimple *last = gsi_stmt (bsi);

      if (gimple_code (last) == GIMPLE_LABEL)
	continue;

      if (is_gimple_debug (last))
	continue;

      if (gimple_code (last) == GIMPLE_COND)
	break;

      if (dump_file && (dump_flags & TDF_DETAILS))
	{
	  fprintf (dump_file, "  Analyzing: ");
	  print_gimple_stmt (dump_file, last, 0, TDF_SLIM);
	}

      if (gimple_code (last) == GIMPLE_CALL
	  && (!gimple_inexpensive_call_p (as_a <gcall *> (last))
	      /* IFN_LOOP_DIST_ALIAS means that inner loop is distributed
		 at current loop's header.  Don't copy in this case.  */
	      || gimple_call_internal_p (last, IFN_LOOP_DIST_ALIAS)))
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "  Not duplicating bb %i: it contains call.\n",
		     header->index);
	  if (query)
	    delete query;
	  return ch_impossible;
	}

      /* Classify the stmt is invariant in the loop.  */
      gimple_set_uid (last, 0);
      if (!gimple_vuse (last)
	  && gimple_code (last) != GIMPLE_ASM
	  && (gimple_code (last) != GIMPLE_CALL
	      || gimple_call_flags (last) & ECF_CONST))
	{
	  bool inv = true, static_p = false;
	  ssa_op_iter i;
	  tree op;
	  FOR_EACH_SSA_TREE_OPERAND (op, last, i, SSA_OP_USE)
	    if (!loop_invariant_op_p (loop, op))
	      inv = false;
	  /* Assume that code is reasonably optimized and invariant
	     constants are already identified.  */
	  if (!inv)
	    static_p = loop_static_stmt_p (loop, *ranger, query, last);
	  gimple_set_uid (last, (inv ? 1 : 0) | (static_p ? 2 : 0));
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    {
	      if (inv)
		fprintf (dump_file, "    Stmt is loop invariant\n");
	      if (static_p)
		fprintf (dump_file, "    Stmt is static "
			 "(constant in the first iteration)\n");
	    }
	  /* Loop invariants will be optimized out in loop body after
	     duplication; do not account invariant computation in code
	     size costs.

	     Similarly static computations will be optimized out in the
	     duplicatd header.  */
	  if (inv || static_p)
	    continue;

	  /* Match the following:
	     _1 = i_1 < 10   <- static condtion
	     _2 = n != 0     <- loop invariant condition
	     _3 = _1 & _2    <- combined static and iv statement.  */
	  tree_code code;
	  if (gimple_code (last) == GIMPLE_ASSIGN
	      && ((code = gimple_assign_rhs_code (last)) == BIT_AND_EXPR
		  || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR))
	    {
	      tree op1 = gimple_assign_rhs1 (last);
	      tree op2 = gimple_assign_rhs2 (last);

	      if ((loop_invariant_op_p (loop, op1)
		   || loop_combined_static_and_iv_p (loop, op1)
		   || loop_static_op_p (loop, op1))
		  && (loop_invariant_op_p (loop, op2)
		      || loop_combined_static_and_iv_p (loop, op2)
		      || loop_static_op_p (loop, op2)))
		{
		  /* Duplicating loop header with combned conditional will
		     remove this statement in each copy.  But we account for
		     that later when seeing that condition.
		     
		     Note that this may be overly optimistic for bit operations
		     where the static parameter may still result in non-trivial
		     bit operation.  */
		  gimple_set_uid (last, 4);
		  if (dump_file && (dump_flags & TDF_DETAILS))
		    fprintf (dump_file,
			     "    Stmt combines static and invariant op\n");
		  continue;
		}
	    }
	}

      int insns = estimate_num_insns (last, &eni_size_weights);
      *limit -= insns;
      if (insns)
	code_size_cost = true;
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "    Acconting stmt as %i insns\n", insns);
      if (*limit < 0)
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "  Not duplicating bb %i contains too many insns.\n",
		     header->index);
	  if (query)
	    delete query;
	  return ch_impossible;
	}
    }

  if (dump_file && (dump_flags & TDF_DETAILS))
    {
      fprintf (dump_file, "  Analyzing: ");
      print_gimple_stmt (dump_file, last, 0, TDF_SLIM);
    }

  /* If the condition tests a non-IV loop variant we do not want to rotate
     the loop further.  Unless this is the original loop header.  */
  tree lhs = gimple_cond_lhs (last);
  tree rhs = gimple_cond_rhs (last);
  bool lhs_invariant = loop_invariant_op_p (loop, lhs);
  bool rhs_invariant = loop_invariant_op_p (loop, rhs);

  /* Combined conditional is a result of if combining:

     _1 = i_1 < 10   <- static condtion
     _2 = n != 0     <- loop invariant condition
     _3 = _1 & _2    <- combined static and iv statement
     if (_3 != 0)    <- combined conditional

     Combined conditionals will not be optimized out in either copy.
     However duplicaed header simplifies to:

     if (n < 10)

     while loop body to

     if (i_1 < 10)

     So effectively the resulting code sequence will be of same length as
     the original code.

     Combined conditionals are never static or invariant, so save some work
     below.  */
  if (lhs_invariant != rhs_invariant
      && (lhs_invariant
	  || loop_combined_static_and_iv_p (loop, lhs))
      && (rhs_invariant
	  || loop_combined_static_and_iv_p (loop, rhs)))
   {
     if (query)
       delete query;
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Conditional combines static and invariant op.\n");
     return ch_win;
   }

  edge static_exit = static_loop_exit (loop, header, *ranger, query);
  if (query)
    delete query;

  if (static_exit && static_exits)
    {
      static_exits->add (static_exit);
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "    Will eliminate peeled conditional in bb %d.\n",
		 static_exit->src->index);
      /* Still look for invariant exits; exit may be both.  */
    }
  if (lhs_invariant && rhs_invariant)
    {
      if (invariant_exits)
	{
	  edge e;
	  edge_iterator ei;
	  FOR_EACH_EDGE (e, ei, header->succs)
	    if (loop_exit_edge_p (loop, e))
	      {
		if (dump_file && (dump_flags & TDF_DETAILS))
		  fprintf (dump_file,
			   "    Will elliminate invariant exit %i->%i\n",
			   e->src->index, e->dest->index);
		invariant_exits->add (e);
	      }
	}
      return ch_win_invariant_exit;
    }

  /* If the static exit fully optimize out, it is win to "duplicate"
     it.

     TODO: Even if duplication costs some size we may opt to do so in case
     exit probability is significant enough (do partial peeling).  */
  if (static_exit)
    return !code_size_cost ? ch_possible_zero_cost : ch_possible;

  /* We was not able to prove that conditional will be eliminated.  */
  int insns = estimate_num_insns (last, &eni_size_weights);
  *limit -= insns;
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file,
	     "    Acconting stmt as %i insns\n", insns);
  if (*limit < 0)
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "  Not duplicating bb %i contains too many insns.\n",
		 header->index);
      return ch_impossible;
    }

  return ch_possible;
}

/* Checks whether LOOP is a do-while style loop.  */

static bool
do_while_loop_p (class loop *loop)
{
  gimple *stmt = last_nondebug_stmt (loop->latch);

  /* If the latch of the loop is not empty, it is not a do-while loop.  */
  if (stmt
      && gimple_code (stmt) != GIMPLE_LABEL)
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Loop %i is not do-while loop: latch is not empty.\n",
		 loop->num);
      return false;
    }

  /* If the latch does not have a single predecessor, it is not a
     do-while loop.  */
  if (!single_pred_p (loop->latch))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Loop %i is not do-while loop: latch has multiple "
		 "predecessors.\n", loop->num);
      return false;
    }
  basic_block pred = single_pred (loop->latch);

  /* If the latch predecessor doesn't exit the loop, it is not a
     do-while loop.  */
  if (!loop_exits_from_bb_p (loop, pred))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Loop %i is not do-while loop: latch predecessor "
		 "does not exit loop.\n", loop->num);
      return false;
    }
  gcond *last = safe_dyn_cast <gcond *> (*gsi_last_bb (pred));
  if (last
      && (gimple_cond_lhs (last) == boolean_false_node
	  || gimple_cond_lhs (last) == boolean_true_node)
      && gimple_cond_rhs (last) == boolean_false_node)
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Loop %i is not do-while loop: latch predecessor "
		 "contains exit we optimized out.\n", loop->num);
      return false;
    }

  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "Loop %i is do-while loop\n", loop->num);

  return true;
}

/* Update profile after header copying of LOOP.
   REGION is the original (in loop) sequence, REGION_COPY is the
   duplicated header (now outside of loop). N_REGION is number of
   bbs duplicated.
   ELIMINATED_EDGE is edge to be removed from duplicated sequence.
   INVARIANT_EXITS are edges in the loop body to be elimianted
   since they are loop invariants

   So We expect the following:

      // region_copy_start entry will be scaled to entry_count
	 if (cond1)         <- this condition will become false
			       and we update probabilities
	   goto loop_exit;
	 if (cond2)         <- this condition is loop invariant
	   goto loop_exit;
	 goto loop_header   <- this will be redirected to loop.
       // region_copy_end
     loop:
	       <body>
       // region start
     loop_header:
	       if (cond1)   <- we need to update probability here
		 goto loop_exit;
	       if (cond2)   <- and determine scaling factor here.
			       moreover cond2 is now always true
		 goto loop_exit;
	       else
		 goto loop;
       // region end

     Adding support for more exits can be done similarly,
     but only consumer so far is tree-ssa-loop-ch and it uses only this
     to handle the common case of peeling headers which have
     conditionals known to be always true upon entry.  */

static void
update_profile_after_ch (class loop *loop,
			 basic_block *region, basic_block *region_copy,
			 unsigned n_region,
			 hash_set <edge> *invariant_exits,
			 hash_set <edge> *static_exits,
			 profile_count entry_count)
{
  for (unsigned int i = 0; i < n_region; i++)
    {
      edge exit_e, exit_e_copy, e, e_copy;
      if (EDGE_COUNT (region[i]->succs) == 1)
	{
	  region_copy[i]->count = entry_count;
	  region[i]->count -= entry_count;
	  continue;
	}

      gcc_checking_assert (EDGE_COUNT (region[i]->succs) == 2);
      if (loop_exit_edge_p (loop,
			    EDGE_SUCC (region[i], 0)))
	{
	  exit_e = EDGE_SUCC (region[i], 0);
	  exit_e_copy = EDGE_SUCC (region_copy[i], 0);
	  e = EDGE_SUCC (region[i], 1);
	  e_copy = EDGE_SUCC (region_copy[i], 1);
	}
      else
	{
	  exit_e = EDGE_SUCC (region[i], 1);
	  exit_e_copy = EDGE_SUCC (region_copy[i], 1);
	  e = EDGE_SUCC (region[i], 0);
	  e_copy = EDGE_SUCC (region_copy[i], 0);
	}
      gcc_assert (i == n_region - 1
		  || (e->dest == region[i + 1]
		      && e_copy->dest == region_copy[i + 1]));
      region_copy[i]->count = entry_count;
      profile_count exit_e_count = exit_e->count ();
      bool was_static = false;
      if (static_exits->contains (exit_e))
	{
	  /* Update profile and the conditional.
	     CFG update is done by caller.  */
	  static_exits->remove (exit_e);
	  was_static = true;
	  e_copy->probability = profile_probability::always ();
	  exit_e_copy->probability = profile_probability::never ();
	  gcond *cond_stmt
		  = as_a <gcond *>(*gsi_last_bb (region_copy[i]));
	  if (e_copy->flags & EDGE_TRUE_VALUE)
	    gimple_cond_make_true (cond_stmt);
	  else
	    gimple_cond_make_false (cond_stmt);
	  update_stmt (cond_stmt);
	  /* Header copying is a special case of jump threading, so use
	     common code to update loop body exit condition.  */
	  update_bb_profile_for_threading (region[i], entry_count, e);
	}
      else
	region[i]->count -= region_copy[i]->count;
      if (invariant_exits->contains (exit_e))
	{
	  invariant_exits->remove (exit_e);
	  /* All exits will happen in exit_e_copy which is out of the
	     loop, so increase probability accordingly.
	     If the edge is eliminated_edge we already corrected
	     profile above.  */
	  if (entry_count.nonzero_p () && !was_static)
	    set_edge_probability_and_rescale_others
		    (exit_e_copy, exit_e_count.probability_in
							(entry_count));
	  /* Eliminate in-loop conditional.  */
	  e->probability = profile_probability::always ();
	  exit_e->probability = profile_probability::never ();
	  gcond *cond_stmt = as_a <gcond *>(*gsi_last_bb (region[i]));
	  if (e->flags & EDGE_TRUE_VALUE)
	    gimple_cond_make_true (cond_stmt);
	  else
	    gimple_cond_make_false (cond_stmt);
	  update_stmt (cond_stmt);
	}
      entry_count = e_copy->count ();
    }
  /* Be sure that we seen all invariant exit edges we are supposed to update.
     We may have recorded some static exists we decided to not duplicate.  */
  gcc_checking_assert (invariant_exits->is_empty ());
}

namespace {

/* Common superclass for both header-copying phases.  */
class ch_base : public gimple_opt_pass
{
  protected:
    ch_base (pass_data data, gcc::context *ctxt)
      : gimple_opt_pass (data, ctxt)
    {}

  /* Copies headers of all loops in FUN for which process_loop_p is true.  */
  unsigned int copy_headers (function *fun);

  /* Return true to copy headers of LOOP or false to skip.  */
  virtual bool process_loop_p (class loop *loop) = 0;
};

const pass_data pass_data_ch =
{
  GIMPLE_PASS, /* type */
  "ch", /* name */
  OPTGROUP_LOOP, /* optinfo_flags */
  TV_TREE_CH, /* tv_id */
  ( PROP_cfg | PROP_ssa ), /* properties_required */
  0, /* properties_provided */
  0, /* properties_destroyed */
  0, /* todo_flags_start */
  0, /* todo_flags_finish */
};

class pass_ch : public ch_base
{
public:
  pass_ch (gcc::context *ctxt)
    : ch_base (pass_data_ch, ctxt)
  {}

  /* opt_pass methods: */
  bool gate (function *) final override { return flag_tree_ch != 0; }

  /* Initialize and finalize loop structures, copying headers inbetween.  */
  unsigned int execute (function *) final override;

  opt_pass * clone () final override { return new pass_ch (m_ctxt); }

protected:
  /* ch_base method: */
  bool process_loop_p (class loop *loop) final override;
}; // class pass_ch

const pass_data pass_data_ch_vect =
{
  GIMPLE_PASS, /* type */
  "ch_vect", /* name */
  OPTGROUP_LOOP, /* optinfo_flags */
  TV_TREE_CH, /* tv_id */
  ( PROP_cfg | PROP_ssa ), /* properties_required */
  0, /* properties_provided */
  0, /* properties_destroyed */
  0, /* todo_flags_start */
  0, /* todo_flags_finish */
};

/* This is a more aggressive version of the same pass, designed to run just
   before if-conversion and vectorization, to put more loops into the form
   required for those phases.  */
class pass_ch_vect : public ch_base
{
public:
  pass_ch_vect (gcc::context *ctxt)
    : ch_base (pass_data_ch_vect, ctxt)
  {}

  /* opt_pass methods: */
  bool gate (function *fun) final override
  {
    return flag_tree_ch != 0
	   && (flag_tree_loop_vectorize != 0 || fun->has_force_vectorize_loops);
  }

  /* Just copy headers, no initialization/finalization of loop structures.  */
  unsigned int execute (function *) final override;

protected:
  /* ch_base method: */
  bool process_loop_p (class loop *loop) final override;
}; // class pass_ch_vect

/* Sort comparator to order loops after the specified order.  */

static int
ch_order_loops (const void *a_, const void *b_, void *order_)
{
  int *order = (int *)order_;
  const class loop *a = *(const class loop * const *)a_;
  const class loop *b = *(const class loop * const *)b_;
  if (a->num == b->num)
    return 0;
  if (order[a->num] < order[b->num])
    return -1;
  return 1;
}

/* For all loops, copy the condition at the end of the loop body in front
   of the loop.  This is beneficial since it increases efficiency of
   code motion optimizations.  It also saves one jump on entry to the loop.  */

unsigned int
ch_base::copy_headers (function *fun)
{
  basic_block *bbs, *copied_bbs;
  unsigned bbs_size;
  bool changed = false;

  if (number_of_loops (fun) <= 1)
    return 0;

  bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (fun));
  copied_bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (fun));
  bbs_size = n_basic_blocks_for_fn (fun);

  struct candidate
    {
      class loop *loop;
      unsigned int nheaders;
      hash_set <edge> *invariant_exits, *static_exits;
    };
  auto_vec<struct candidate> candidates;
  auto_vec<std::pair<edge, loop_p> > copied;
  auto_vec<class loop *> loops_to_unloop;
  auto_vec<int> loops_to_unloop_nunroll;

  mark_dfs_back_edges ();
  gimple_ranger *ranger = new gimple_ranger;
  for (auto loop : loops_list (cfun, 0))
    {
      int initial_limit = optimize_loop_for_speed_p (loop)
			  ? param_max_loop_header_insns : 0;
      int remaining_limit = initial_limit;
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Analyzing loop %i\n", loop->num);

      /* If the loop is already a do-while style one (either because it was
	 written as such, or because jump threading transformed it into one),
	 we might be in fact peeling the first iteration of the loop.  This
	 in general is not a good idea.  Also avoid touching infinite loops.  */
      if (!loop_has_exit_edges (loop)
	  || !process_loop_p (loop))
	continue;

      basic_block header = loop->header;
      estimate_numbers_of_iterations (loop);
      if (!get_max_loop_iterations_int (loop))
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file, "Loop %d never loops.\n", loop->num);
	  scale_loop_profile (loop, profile_probability::always (), 0);
	  loops_to_unloop.safe_push (loop);
	  loops_to_unloop_nunroll.safe_push (0);
	  continue;
	}

      /* Iterate the header copying up to limit; this takes care of the cases
	 like while (a && b) {...}, where we want to have both of the conditions
	 copied.  TODO -- handle while (a || b) - like cases, by not requiring
	 the header to have just a single successor and copying up to
	 postdominator.  */
      unsigned int nheaders = 0;
      unsigned int last_win_nheaders = 0;
      bool last_win_invariant_exit = false;
      ch_decision ret;
      auto_vec <ch_decision, 32> decision;
      hash_set <edge> *invariant_exits = new hash_set <edge>;
      hash_set <edge> *static_exits = new hash_set <edge>;
      while ((ret = should_duplicate_loop_header_p (header, loop, ranger,
						    &remaining_limit,
						    invariant_exits,
						    static_exits))
	     != ch_impossible)
	{
	  nheaders++;
	  decision.safe_push (ret);
	  if (ret >= ch_win)
	    {
	      last_win_nheaders = nheaders;
	      last_win_invariant_exit = (ret == ch_win_invariant_exit);
	      if (dump_file && (dump_flags & TDF_DETAILS))
		fprintf (dump_file, "    Duplicating bb %i is a win\n",
			 header->index);
	    }
	  else
	    if (dump_file && (dump_flags & TDF_DETAILS))
	      fprintf (dump_file, "    May duplicate bb %i\n", header->index);

	  /* Find a successor of header that is inside a loop; i.e. the new
	     header after the condition is copied.  */
	  if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest))
	    header = EDGE_SUCC (header, 0)->dest;
	  else
	    header = EDGE_SUCC (header, 1)->dest;
	}

      /* Try to turn loop into do-while.  This means ensuring that
	 last duplicated header will not have loop invariant exit.  */
      if (last_win_nheaders && last_win_invariant_exit
	  && nheaders > last_win_nheaders)
	{
	  last_win_nheaders++;
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "    Duplicating additional BB to obtain do-while loop\n");
	}
      else if (!last_win_nheaders && nheaders && !do_while_loop_p (loop))
	{
	  last_win_nheaders = 1;
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "    Duplicating header BB to obtain do-while loop\n");
	}
      /* "Duplicate" all BBs with zero cost following last basic blocks we
	 decided to copy.  */
      while (last_win_nheaders < decision.length ()
	     && decision[last_win_nheaders] == ch_possible_zero_cost)
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "    Duplicating extra bb is a win; it has zero cost\n");
	  last_win_nheaders++;
	}

      if (last_win_nheaders)
	candidates.safe_push ({loop, last_win_nheaders,
			      invariant_exits, static_exits});
      else
	{
	  delete invariant_exits;
	  delete static_exits;
	}
    }
  /* Do not use ranger after we change the IL and not have updated SSA.  */
  delete ranger;

  for (auto candidate : candidates)
    {
      class loop *loop = candidate.loop;
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Copying headers of loop %i\n", loop->num);

      basic_block header = loop->header;
      edge nonexit = NULL;
      edge exit = NULL;
      unsigned int n_bbs = 0;
      int nexits = 0;
      profile_count exit_count = profile_count::zero ();
      profile_count entry_count = profile_count::zero ();
      edge e;
      edge_iterator ei;

      FOR_EACH_EDGE (e, ei, loop->header->preds)
	if (e->src != loop->latch)
	  entry_count += e->count ();
      while (n_bbs < candidate.nheaders)
	{
	    if (dump_file && (dump_flags & TDF_DETAILS))
	      fprintf (dump_file, "    Will duplicate bb %i\n", header->index);
	  /* Find a successor of header that is inside a loop; i.e. the new
	     header after the condition is copied.  */
	  if (flow_bb_inside_loop_p (loop, EDGE_SUCC (header, 0)->dest))
	    {
	      nonexit = EDGE_SUCC (header, 0);
	      exit = EDGE_SUCC (header, 1);
	    }
	  else
	    {
	      nonexit = EDGE_SUCC (header, 1);
	      exit = EDGE_SUCC (header, 0);
	    }
	  exit_count += exit->count ();
	  nexits++;
	  bbs[n_bbs++] = header;
	  gcc_assert (bbs_size > n_bbs);
	  header = nonexit->dest;
	}

      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Duplicating header of the loop %d up to edge %d->%d\n",
		 loop->num, exit->src->index, exit->dest->index);

      /* Ensure that the header will have just the latch as a predecessor
	 inside the loop.  */
      if (!single_pred_p (nonexit->dest))
	{
	  header = split_edge (nonexit);
	  exit = single_pred_edge (header);
	}

      edge entry = loop_preheader_edge (loop);

      propagate_threaded_block_debug_into (nonexit->dest, entry->dest);
      if (!gimple_duplicate_seme_region (entry, exit, bbs, n_bbs, copied_bbs,
					 true))
	{
	  delete candidate.static_exits;
	  delete candidate.invariant_exits;
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file, "Duplication failed.\n");
	  continue;
	}
      if (loop->header->count.initialized_p ())
	update_profile_after_ch (loop, bbs, copied_bbs, n_bbs,
				 candidate.invariant_exits,
				 candidate.static_exits,
				 entry_count);
      delete candidate.static_exits;
      delete candidate.invariant_exits;
      copied.safe_push (std::make_pair (entry, loop));

      /* If the loop has the form "for (i = j; i < j + 10; i++)" then
	 this copying can introduce a case where we rely on undefined
	 signed overflow to eliminate the preheader condition, because
	 we assume that "j < j + 10" is true.  We don't want to warn
	 about that case for -Wstrict-overflow, because in general we
	 don't warn about overflow involving loops.  Prevent the
	 warning by setting the no_warning flag in the condition.  */
      if (warn_strict_overflow > 0)
	{
	  unsigned int i;

	  for (i = 0; i < n_bbs; ++i)
	    {
	      gimple_stmt_iterator bsi;

	      for (bsi = gsi_start_bb (copied_bbs[i]);
		   !gsi_end_p (bsi);
		   gsi_next (&bsi))
		{
		  gimple *stmt = gsi_stmt (bsi);
		  if (gimple_code (stmt) == GIMPLE_COND)
		    {
		      tree lhs = gimple_cond_lhs (stmt);
		      if (gimple_cond_code (stmt) != EQ_EXPR
			  && gimple_cond_code (stmt) != NE_EXPR
			  && INTEGRAL_TYPE_P (TREE_TYPE (lhs))
			  && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (lhs)))
			suppress_warning (stmt, OPT_Wstrict_overflow_);
		    }
		  else if (is_gimple_assign (stmt))
		    {
		      enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
		      tree rhs1 = gimple_assign_rhs1 (stmt);
		      if (TREE_CODE_CLASS (rhs_code) == tcc_comparison
			  && rhs_code != EQ_EXPR
			  && rhs_code != NE_EXPR
			  && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
			  && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1)))
			suppress_warning (stmt, OPT_Wstrict_overflow_);
		    }
		}
	    }
	}

      /* Update header of the loop.  */
      loop->header = header;
      /* Find correct latch.  We only duplicate chain of conditionals so
	 there should be precisely two edges to the new header.  One entry
	 edge and one to latch.  */
      FOR_EACH_EDGE (e, ei, loop->header->preds)
	if (header != e->src)
	  {
	    loop->latch = e->src;
	    break;
	  }
      /* Ensure that the latch is simple.  */
      if (!single_succ_p (loop_latch_edge (loop)->src))
	split_edge (loop_latch_edge (loop));

      if (dump_file && (dump_flags & TDF_DETAILS))
	{
	  if (do_while_loop_p (loop))
	    fprintf (dump_file, "Loop %d is now do-while loop.\n", loop->num);
	  else
	    fprintf (dump_file, "Loop %d is still not do-while loop.\n",
		     loop->num);
	  fprintf (dump_file, "Exit count: ");
	  exit_count.dump (dump_file);
	  fprintf (dump_file, "\nEntry count: ");
	  entry_count.dump (dump_file);
	  fprintf (dump_file, "\n");
	}

      /* We possibly decreased number of iterations by 1.  */
      auto_vec<edge> exits = get_loop_exit_edges (loop);
      bool precise = (nexits == (int) exits.length ());
      /* Check that loop may not terminate in other way than via
	 basic blocks we duplicated.  */
      if (precise)
	{
	  basic_block *bbs = get_loop_body (loop);
	  for (unsigned i = 0; i < loop->num_nodes && precise; ++i)
	   {
	     basic_block bb = bbs[i];
	     bool found_exit = false;
	     FOR_EACH_EDGE (e, ei, bb->succs)
	      if (!flow_bb_inside_loop_p (loop, e->dest))
		{
		  found_exit = true;
		  break;
		}
	     /* If BB has exit, it was duplicated.  */
	     if (found_exit)
	       continue;
	     /* Give up on irreducible loops.  */
	     if (bb->flags & BB_IRREDUCIBLE_LOOP)
	       {
		 precise = false;
		 break;
	       }
	     /* Check that inner loops are finite.  */
	     for (class loop *l = bb->loop_father; l != loop && precise;
		  l = loop_outer (l))
	       if (!l->finite_p)
		 {
		   precise = false;
		   break;
		 }
	     /* Verify that there is no statement that may be terminate
		execution in a way not visible to CFG.  */
	     for (gimple_stmt_iterator bsi = gsi_start_bb (bb);
		  !gsi_end_p (bsi); gsi_next (&bsi))
	       if (stmt_can_terminate_bb_p (gsi_stmt (bsi)))
		 precise = false;
	   }
	  free (bbs);
	}
      if (precise
	  && get_max_loop_iterations_int (loop) == 1)
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file, "Loop %d no longer loops.\n", loop->num);
	  scale_loop_profile (loop, profile_probability::always (), 0);
	  loops_to_unloop.safe_push (loop);
	  loops_to_unloop_nunroll.safe_push (0);
	}
      else if (precise)
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "Peeled all exits:"
		     " decreased number of iterations of loop %d by 1.\n",
		     loop->num);
	  adjust_loop_info_after_peeling (loop, 1, true);
	}
      else if (exit_count >= entry_count.apply_scale (9, 10))
	{
	  if (dump_file && (dump_flags & TDF_DETAILS))
	    fprintf (dump_file,
		     "Peeled likely exits: likely decreased number "
		     "of iterations of loop %d by 1.\n", loop->num);
	  adjust_loop_info_after_peeling (loop, 1, false);
	}
      else if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file,
		 "Not decreased number"
		 " of iterations of loop %d; likely exits remains.\n",
		 loop->num);

      changed = true;
    }

  if (changed)
    {
      update_ssa (TODO_update_ssa);
      /* After updating SSA form perform CSE on the loop header
	 copies.  This is esp. required for the pass before
	 vectorization since nothing cleans up copied exit tests
	 that can now be simplified.  CSE from the entry of the
	 region we copied till all loop exit blocks but not
	 entering the loop itself.  */
      for (unsigned i = 0; i < copied.length (); ++i)
	{
	  edge entry = copied[i].first;
	  loop_p loop = copied[i].second;
	  auto_vec<edge> exit_edges = get_loop_exit_edges (loop);
	  bitmap exit_bbs = BITMAP_ALLOC (NULL);
	  for (unsigned j = 0; j < exit_edges.length (); ++j)
	    bitmap_set_bit (exit_bbs, exit_edges[j]->dest->index);
	  bitmap_set_bit (exit_bbs, loop->header->index);
	  do_rpo_vn (cfun, entry, exit_bbs);
	  BITMAP_FREE (exit_bbs);
	}
    }
  if (!loops_to_unloop.is_empty ())
    {
      /* Make sure loops are ordered inner to outer for unlooping.  */
      if (loops_to_unloop.length () != 1)
	{
	  auto_vec<int, 8> order;
	  order.safe_grow (number_of_loops (cfun), true);
	  int i = 0;
	  for (auto loop : loops_list (cfun, LI_FROM_INNERMOST))
	    order[loop->num] = i++;
	  loops_to_unloop.sort (ch_order_loops, order.address ());
	}
      bool irred_invalidated;
      auto_bitmap lc_invalidated;
      auto_vec<edge> edges_to_remove;
      unloop_loops (loops_to_unloop, loops_to_unloop_nunroll, edges_to_remove,
		    lc_invalidated, &irred_invalidated);
      if (loops_state_satisfies_p (fun, LOOP_CLOSED_SSA)
	  && !bitmap_empty_p (lc_invalidated))
	rewrite_into_loop_closed_ssa (NULL, 0);
      changed = true;
    }
  free (bbs);
  free (copied_bbs);

  return changed ? TODO_cleanup_cfg : 0;
}

/* Initialize the loop structures we need, and finalize after.  */

unsigned int
pass_ch::execute (function *fun)
{
  loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
  scev_initialize ();

  unsigned int res = copy_headers (fun);

  scev_finalize ();
  loop_optimizer_finalize ();
  return res;
}

/* Assume an earlier phase has already initialized all the loop structures that
   we need here (and perhaps others too), and that these will be finalized by
   a later phase.  */

unsigned int
pass_ch_vect::execute (function *fun)
{
  return copy_headers (fun);
}

/* Apply header copying according to a very simple test of do-while shape.  */

bool
pass_ch::process_loop_p (class loop *)
{
  return true;
}

/* Apply header-copying to loops where we might enable vectorization.  */

bool
pass_ch_vect::process_loop_p (class loop *loop)
{
  if (!flag_tree_loop_vectorize && !loop->force_vectorize)
    return false;

  if (loop->dont_vectorize)
    return false;

  /* The vectorizer won't handle anything with multiple exits, so skip.  */
  edge exit = single_exit (loop);
  if (!exit)
    return false;

  if (!do_while_loop_p (loop))
    return true;

  return false;
}

} // anon namespace

gimple_opt_pass *
make_pass_ch_vect (gcc::context *ctxt)
{
  return new pass_ch_vect (ctxt);
}

gimple_opt_pass *
make_pass_ch (gcc::context *ctxt)
{
  return new pass_ch (ctxt);
}