[PATCH] Remove legacy back threader.

Aldy Hernandez aldyh@redhat.com
Thu Aug 12 14:34:43 GMT 2021


PING

On Thu, Aug 5, 2021 at 11:48 AM Aldy Hernandez <aldyh@redhat.com> wrote:
>
> At this point I don't see any use for the legacy mode, which I had
> originally left in place during the transition.
>
> This patch removes the legacy back threader, and cleans up the code a
> bit.  There are no functional changes to the non-legacy code.
>
> Tested on x86-64 Linux.
>
> OK?
>
> gcc/ChangeLog:
>
>         * doc/invoke.texi: Remove docs for threader-mode param.
>         * flag-types.h (enum threader_mode): Remove.
>         * params.opt: Remove threader-mode param.
>         * tree-ssa-threadbackward.c (class back_threader): Remove
>         path_is_unreachable_p.
>         Make find_paths private.
>         Add maybe_thread and thread_through_all_blocks.
>         Remove reference marker for m_registry.
>         Remove reference marker for m_profit.
>         (back_threader::back_threader): Adjust for registry and profit not
>         being references.
>         (dump_path): Move down.
>         (debug): Move down.
>         (class thread_jumps): Remove.
>         (class back_threader_registry): Remove m_all_paths.
>         Remove destructor.
>         (thread_jumps::thread_through_all_blocks): Move to back_threader
>         class.
>         (fsm_find_thread_path): Remove
>         (back_threader::maybe_thread): New.
>         (back_threader::thread_through_all_blocks): Move from
>         thread_jumps.
>         (back_threader_registry::back_threader_registry): Remove
>         m_all_paths.
>         (back_threader_registry::~back_threader_registry): Remove.
>         (thread_jumps::find_taken_edge): Remove.
>         (thread_jumps::check_subpath_and_update_thread_path): Remove.
>         (thread_jumps::maybe_register_path): Remove.
>         (thread_jumps::handle_phi): Remove.
>         (handle_assignment_p): Remove.
>         (thread_jumps::handle_assignment): Remove.
>         (thread_jumps::fsm_find_control_statement_thread_paths): Remove.
>         (thread_jumps::find_jump_threads_backwards): Remove.
>         (thread_jumps::find_jump_threads_backwards_with_ranger): Remove.
>         (try_thread_blocks): Rename find_jump_threads_backwards to
>         maybe_thread.
>         (pass_early_thread_jumps::execute): Same.
>
> gcc/testsuite/ChangeLog:
>
>         * gcc.dg/tree-ssa/ssa-dom-thread-7.c: Remove call into the legacy
>         code and adjust for ranger threader.
> ---
>  gcc/doc/invoke.texi                           |   3 -
>  gcc/flag-types.h                              |   7 -
>  gcc/params.opt                                |  13 -
>  .../gcc.dg/tree-ssa/ssa-dom-thread-7.c        |   3 +-
>  gcc/tree-ssa-threadbackward.c                 | 539 ++----------------
>  5 files changed, 61 insertions(+), 504 deletions(-)
>
> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
> index 4efc8b757ec..65bb9981f02 100644
> --- a/gcc/doc/invoke.texi
> +++ b/gcc/doc/invoke.texi
> @@ -13421,9 +13421,6 @@ Setting to 0 disables the analysis completely.
>  @item modref-max-escape-points
>  Specifies the maximum number of escape points tracked by modref per SSA-name.
>
> -@item threader-mode
> -Specifies the mode the backwards threader should run in.
> -
>  @item profile-func-internal-id
>  A parameter to control whether to use function internal id in profile
>  database lookup. If the value is 0, the compiler uses an id that
> diff --git a/gcc/flag-types.h b/gcc/flag-types.h
> index e39673f6716..e43d1de490d 100644
> --- a/gcc/flag-types.h
> +++ b/gcc/flag-types.h
> @@ -454,13 +454,6 @@ enum evrp_mode
>    EVRP_MODE_RVRP_DEBUG = EVRP_MODE_RVRP_ONLY | EVRP_MODE_DEBUG
>  };
>
> -/* Backwards threader mode.  */
> -enum threader_mode
> -{
> -  THREADER_MODE_LEGACY = 0,
> -  THREADER_MODE_RANGER = 1
> -};
> -
>  /* Modes of OpenACC 'kernels' constructs handling.  */
>  enum openacc_kernels
>  {
> diff --git a/gcc/params.opt b/gcc/params.opt
> index aa2fb4047b6..92b003e38cb 100644
> --- a/gcc/params.opt
> +++ b/gcc/params.opt
> @@ -1010,19 +1010,6 @@ Maximum depth of DFS walk used by modref escape analysis.
>  Common Joined UInteger Var(param_modref_max_escape_points) Init(256) Param Optimization
>  Maximum number of escape points tracked by modref per SSA-name.
>
> --param=threader-mode=
> -Common Joined Var(param_threader_mode) Enum(threader_mode) Init(THREADER_MODE_RANGER) Param Optimization
> ---param=threader-mode=[legacy|ranger] Specifies the mode the backwards threader should run in.
> -
> -Enum
> -Name(threader_mode) Type(enum threader_mode) UnknownError(unknown threader mode %qs)
> -
> -EnumValue
> -Enum(threader_mode) String(legacy) Value(THREADER_MODE_LEGACY)
> -
> -EnumValue
> -Enum(threader_mode) String(ranger) Value(THREADER_MODE_RANGER)
> -
>  -param=tm-max-aggregate-size=
>  Common Joined UInteger Var(param_tm_max_aggregate_size) Init(9) Param Optimization
>  Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs.
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-7.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-7.c
> index 1c2d12aa9ea..5fc2145a432 100644
> --- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-7.c
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-7.c
> @@ -1,6 +1,5 @@
>  /* { dg-do compile } */
>  /* { dg-options "-O2 -fdump-tree-thread1-stats -fdump-tree-thread2-stats -fdump-tree-dom2-stats -fdump-tree-thread3-stats -fdump-tree-dom3-stats -fdump-tree-vrp2-stats -fno-guess-branch-probability" } */
> -/* { dg-additional-options "--param=threader-mode=legacy" } */
>
>  /* Here we have the same issue as was commented in ssa-dom-thread-6.c.
>     The PHI coming into the threader has a lot more constants, so the
> @@ -17,7 +16,7 @@ $ diff clean/a.c.105t.mergephi2 a.c.105t.mergephi2
>    basically tracking the switch index better through multiple
>    paths.  */
>
> -/* { dg-final { scan-tree-dump "Jumps threaded: 19"  "thread1" } } */
> +/* { dg-final { scan-tree-dump "Jumps threaded: 18"  "thread1" } } */
>  /* { dg-final { scan-tree-dump "Jumps threaded: 8" "thread2" } } */
>  /* { dg-final { scan-tree-dump-not "Jumps threaded"  "dom2" } } */
>
> diff --git a/gcc/tree-ssa-threadbackward.c b/gcc/tree-ssa-threadbackward.c
> index 91ce443b1b2..266b98a39e2 100644
> --- a/gcc/tree-ssa-threadbackward.c
> +++ b/gcc/tree-ssa-threadbackward.c
> @@ -51,12 +51,10 @@ class back_threader_registry
>  {
>  public:
>    back_threader_registry (int max_allowable_paths);
> -  ~back_threader_registry ();
>    bool register_path (const vec<basic_block> &, edge taken);
>    bool thread_through_all_blocks ();
>
>  private:
> -  vec<vec<basic_block>> m_all_paths;
>    jump_thread_path_registry m_lowlevel_registry;
>    const int m_max_allowable_paths;
>    int m_threaded_paths;
> @@ -77,19 +75,16 @@ private:
>    const bool m_speed_p;
>  };
>
> -// Ranger based backwards threader.
> -
>  class back_threader
>  {
> -  // Temporary until we remove old code.
> -  friend bool path_is_unreachable_p (const vec<jump_thread_edge *> &);
> -
>  public:
> -  back_threader (back_threader_profitability &, back_threader_registry &);
> +  back_threader (bool speed_p);
>    ~back_threader ();
> -  void find_paths (basic_block bb, tree name);
> +  void maybe_thread (basic_block bb);
> +  bool thread_through_all_blocks ();
>
>  private:
> +  void find_paths (basic_block bb, tree name);
>    void maybe_register_path (edge taken_edge);
>    bool find_paths_to_names (basic_block bb, bitmap imports);
>    bool resolve_def (tree name, bitmap interesting, vec<tree> worklist);
> @@ -98,8 +93,8 @@ private:
>    edge find_taken_edge_cond (const vec<basic_block> &path, gcond *);
>    edge find_taken_edge_switch (const vec<basic_block> &path, gswitch *);
>
> -  back_threader_registry &m_registry;
> -  back_threader_profitability &m_profit;
> +  back_threader_registry m_registry;
> +  back_threader_profitability m_profit;
>    gimple_ranger m_ranger;
>    path_range_query m_solver;
>
> @@ -123,10 +118,9 @@ private:
>  // in a the given direction.
>  const edge back_threader::UNREACHABLE_EDGE = (edge) -1;
>
> -back_threader::back_threader (back_threader_profitability &profit,
> -                             back_threader_registry &registry)
> -  : m_registry (registry),
> -    m_profit (profit),
> +back_threader::back_threader (bool speed_p)
> +  : m_registry (param_max_fsm_thread_paths),
> +    m_profit (speed_p),
>      m_solver (m_ranger)
>  {
>    m_last_stmt = NULL;
> @@ -456,74 +450,9 @@ back_threader::find_paths (basic_block bb, tree name)
>      }
>  }
>
> -// Dump a sequence of BBs through the CFG.
> -
> -DEBUG_FUNCTION void
> -dump_path (FILE *dump_file, const vec<basic_block> &path)
> -{
> -  for (size_t i = 0; i < path.length (); ++i)
> -    {
> -      fprintf (dump_file, "BB%d", path[i]->index);
> -      if (i + 1 < path.length ())
> -       fprintf (dump_file, " <- ");
> -    }
> -  fprintf (dump_file, "\n");
> -}
> -
> -DEBUG_FUNCTION void
> -debug (const vec <basic_block> &path)
> -{
> -  dump_path (stderr, path);
> -}
> -
> -class thread_jumps
> -{
> -public:
> -  thread_jumps (bool speed_p = true)
> -    : m_profit (speed_p),
> -      m_registry (param_max_fsm_thread_paths),
> -      m_back_threader (m_profit, m_registry)
> -  { }
> -  void find_jump_threads_backwards (basic_block bb);
> -  void find_jump_threads_backwards_with_ranger (basic_block bb);
> -  bool thread_through_all_blocks ();
> -
> -private:
> -  void maybe_register_path (const vec<basic_block> &m_path,
> -                           tree name,
> -                           edge taken_edge);
> -  edge find_taken_edge (const vec<basic_block> &path, tree arg);
> -  void handle_assignment (gimple *stmt, basic_block def_bb);
> -  void handle_phi (gphi *phi, basic_block def_bb);
> -  void fsm_find_control_statement_thread_paths (tree name);
> -  bool check_subpath_and_update_thread_path (basic_block last_bb,
> -                                            basic_block new_bb,
> -                                            int *next_path_length);
> -
> -  /* Hash to keep track of seen bbs.  */
> -  hash_set<basic_block> m_visited_bbs;
> -  /* Current path we're analyzing.  */
> -  auto_vec<basic_block> m_path;
> -  /* Tracks if we have recursed through a loop PHI node.  */
> -  bool m_seen_loop_phi;
> -
> -  tree m_name;
> -  back_threader_profitability m_profit;
> -  back_threader_registry m_registry;
> -  back_threader m_back_threader;
> -};
> -
> -// Perform the actual jump threading for the all queued paths.
> -
> -bool
> -thread_jumps::thread_through_all_blocks ()
> -{
> -  return m_registry.thread_through_all_blocks ();
> -}
> -
> -/* Simple helper to get the last statement from BB, which is assumed
> -   to be a control statement.   Return NULL if the last statement is
> -   not a control statement.  */
> +// Simple helper to get the last statement from BB, which is assumed
> +// to be a control statement.  Return NULL if the last statement is
> +// not a control statement.
>
>  static gimple *
>  get_gimple_control_stmt (basic_block bb)
> @@ -540,55 +469,65 @@ get_gimple_control_stmt (basic_block bb)
>    return NULL;
>  }
>
> -/* Return true if the CFG contains at least one path from START_BB to
> -   END_BB.  When a path is found, record in PATH the blocks from
> -   END_BB to START_BB.  LOCAL_VISITED_BBS is used to make sure we
> -   don't fall into an infinite loop.  Bound the recursion to basic
> -   blocks belonging to LOOP.  */
> +// Search backwards from BB looking for paths where the final
> +// conditional maybe threaded to a successor block.  Record such paths
> +// for jump threading.
>
> -static bool
> -fsm_find_thread_path (basic_block start_bb, basic_block end_bb,
> -                     vec<basic_block> &path,
> -                     hash_set<basic_block> &local_visited_bbs,
> -                     loop_p loop)
> +void
> +back_threader::maybe_thread (basic_block bb)
>  {
> -  if (loop != start_bb->loop_father)
> -    return false;
> +  gimple *stmt = get_gimple_control_stmt (bb);
> +  if (!stmt)
> +    return;
>
> -  if (start_bb == end_bb)
> -    {
> -      path.safe_push (start_bb);
> -      return true;
> -    }
> +  enum gimple_code code = gimple_code (stmt);
> +  tree name;
> +  if (code == GIMPLE_SWITCH)
> +    name = gimple_switch_index (as_a <gswitch *> (stmt));
> +  else if (code == GIMPLE_COND)
> +    name = gimple_cond_lhs (stmt);
> +  else if (code == GIMPLE_GOTO)
> +    name = gimple_goto_dest (stmt);
> +  else
> +    name = NULL;
>
> -  if (!local_visited_bbs.add (start_bb))
> +  find_paths (bb, name);
> +}
> +
> +// Perform the actual jump threading for the all queued paths.
> +
> +bool
> +back_threader::thread_through_all_blocks ()
> +{
> +  return m_registry.thread_through_all_blocks ();
> +}
> +
> +// Dump a sequence of BBs through the CFG.
> +
> +DEBUG_FUNCTION void
> +dump_path (FILE *dump_file, const vec<basic_block> &path)
> +{
> +  for (size_t i = 0; i < path.length (); ++i)
>      {
> -      edge e;
> -      edge_iterator ei;
> -      FOR_EACH_EDGE (e, ei, start_bb->succs)
> -       if (fsm_find_thread_path (e->dest, end_bb, path, local_visited_bbs,
> -                                 loop))
> -         {
> -           path.safe_push (start_bb);
> -           return true;
> -         }
> +      fprintf (dump_file, "BB%d", path[i]->index);
> +      if (i + 1 < path.length ())
> +       fprintf (dump_file, " <- ");
>      }
> +  fprintf (dump_file, "\n");
> +}
>
> -  return false;
> +DEBUG_FUNCTION void
> +debug (const vec <basic_block> &path)
> +{
> +  dump_path (stderr, path);
>  }
>
>  back_threader_registry::back_threader_registry (int max_allowable_paths)
>    : m_max_allowable_paths (max_allowable_paths)
>  {
> -  m_all_paths.create (5);
>    m_threaded_paths = 0;
>  }
>
> -back_threader_registry::~back_threader_registry ()
> -{
> -  m_all_paths.release ();
> -}
> -
>  bool
>  back_threader_registry::thread_through_all_blocks ()
>  {
> @@ -881,39 +820,6 @@ back_threader_profitability::profitable_path_p (const vec<basic_block> &m_path,
>    return true;
>  }
>
> -/* Return the taken edge out of a path, assuming that the underlying assignment
> -   or PHI SSA resolves to ARG.  */
> -
> -edge
> -thread_jumps::find_taken_edge (const vec<basic_block> &path, tree arg)
> -{
> -  if (TREE_CODE_CLASS (TREE_CODE (arg)) != tcc_constant)
> -    return NULL;
> -
> -  gcc_checking_assert (!path.is_empty ());
> -  gimple *stmt = get_gimple_control_stmt (m_path[0]);
> -
> -  /* We have found a constant value for ARG.  For GIMPLE_SWITCH
> -     and GIMPLE_GOTO, we use it as-is.  However, for a GIMPLE_COND
> -     we need to substitute, fold and simplify so we can determine
> -     the edge taken out of the last block.  */
> -  if (gimple_code (stmt) == GIMPLE_COND)
> -    {
> -      enum tree_code cond_code = gimple_cond_code (stmt);
> -
> -      /* We know the underyling format of the condition.  */
> -      arg = fold_binary (cond_code, boolean_type_node,
> -                        arg, gimple_cond_rhs (stmt));
> -    }
> -
> -  /* If this path threaded through the loop latch back into the
> -     same loop and the destination does not dominate the loop
> -     latch, then this thread would create an irreducible loop.
> -
> -     We have to know the outgoing edge to figure this out.  */
> -  return ::find_taken_edge (m_path[0], arg);
> -}
> -
>  /* The current path PATH is a vector of blocks forming a jump threading
>     path in reverse order.  TAKEN_EDGE is the edge taken from path[0].
>
> @@ -962,331 +868,6 @@ back_threader_registry::register_path (const vec<basic_block> &m_path,
>    return true;
>  }
>
> -/* While following a chain of SSA_NAME definitions, we jumped from a
> -   definition in LAST_BB to a definition in NEW_BB (walking
> -   backwards).
> -
> -   Verify there is a single path between the blocks and none of the
> -   blocks in the path is already in VISITED_BBS.  If so, then update
> -   VISISTED_BBS, add the new blocks to PATH and return TRUE.
> -   Otherwise return FALSE.
> -
> -   Store the length of the subpath in NEXT_PATH_LENGTH.  */
> -
> -bool
> -thread_jumps::check_subpath_and_update_thread_path (basic_block last_bb,
> -                                                   basic_block new_bb,
> -                                                   int *next_path_length)
> -{
> -  edge e;
> -  int e_count = 0;
> -  edge_iterator ei;
> -  auto_vec<basic_block> next_path;
> -
> -  FOR_EACH_EDGE (e, ei, last_bb->preds)
> -    {
> -      hash_set<basic_block> local_visited_bbs;
> -
> -      if (fsm_find_thread_path (new_bb, e->src, next_path,
> -                               local_visited_bbs, e->src->loop_father))
> -       ++e_count;
> -
> -      /* If there is more than one path, stop.  */
> -      if (e_count > 1)
> -       return false;
> -    }
> -
> -  /* Stop if we have not found a path: this could occur when the recursion
> -     is stopped by one of the bounds.  */
> -  if (e_count == 0)
> -    return false;
> -
> -  /* Make sure we haven't already visited any of the nodes in
> -     NEXT_PATH.  Don't add them here to avoid pollution.  */
> -  for (unsigned int i = 0; i + 1 < next_path.length (); i++)
> -    {
> -      if (m_visited_bbs.contains (next_path[i]))
> -       return false;
> -    }
> -
> -  /* Now add the nodes to VISISTED_BBS.  */
> -  for (unsigned int i = 0; i + 1 < next_path.length (); i++)
> -    m_visited_bbs.add (next_path[i]);
> -
> -  /* Append all the nodes from NEXT_PATH to PATH.  */
> -  m_path.safe_splice (next_path);
> -  *next_path_length = next_path.length ();
> -
> -  return true;
> -}
> -
> -/* If this is a profitable jump thread path, register it.
> -
> -   NAME is an SSA NAME with a possible constant value of ARG on PATH.
> -
> -   DEF_BB is the basic block that ultimately defines the constant.  */
> -
> -void
> -thread_jumps::maybe_register_path (const vec<basic_block> &m_path,
> -                                  tree name,
> -                                  edge taken_edge)
> -{
> -  bool irreducible = false;
> -  bool profitable = m_profit.profitable_path_p (m_path, name, taken_edge,
> -                                               &irreducible);
> -  if (profitable)
> -    {
> -      if (!m_registry.register_path (m_path, taken_edge))
> -       return;
> -
> -      if (irreducible)
> -       vect_free_loop_info_assumptions (m_path[0]->loop_father);
> -    }
> -}
> -
> -/* Given PHI which defines NAME in block DEF_BB, recurse through the
> -   PHI's arguments searching for paths where NAME will ultimately have
> -   a constant value.
> -
> -   PATH contains the series of blocks to traverse that will result in
> -   NAME having a constant value.  */
> -
> -void
> -thread_jumps::handle_phi (gphi *phi, basic_block def_bb)
> -{
> -  /* Iterate over the arguments of PHI.  */
> -  for (unsigned int i = 0; i < gimple_phi_num_args (phi); i++)
> -    {
> -      tree arg = gimple_phi_arg_def (phi, i);
> -      basic_block bbi = gimple_phi_arg_edge (phi, i)->src;
> -
> -      /* Skip edges pointing outside the current loop.  */
> -      if (!arg || def_bb->loop_father != bbi->loop_father)
> -       continue;
> -
> -      if (TREE_CODE (arg) == SSA_NAME)
> -       {
> -         m_path.safe_push (bbi);
> -         /* Recursively follow SSA_NAMEs looking for a constant
> -            definition.  */
> -         fsm_find_control_statement_thread_paths (arg);
> -
> -         m_path.pop ();
> -         continue;
> -       }
> -
> -      m_path.safe_push (bbi);
> -      edge taken_edge = find_taken_edge (m_path, arg);
> -      if (taken_edge)
> -       maybe_register_path (m_path, m_name, taken_edge);
> -      m_path.pop ();
> -    }
> -}
> -
> -/* Return TRUE if STMT is a gimple assignment we want to either directly
> -   handle or recurse through.  Return FALSE otherwise.
> -
> -   Note that adding more cases here requires adding cases to handle_assignment
> -   below.  */
> -
> -static bool
> -handle_assignment_p (gimple *stmt)
> -{
> -  if (is_gimple_assign (stmt))
> -    {
> -      enum tree_code def_code = gimple_assign_rhs_code (stmt);
> -
> -      /* If the RHS is an SSA_NAME, then we will recurse through it.
> -        Go ahead and filter out cases where the SSA_NAME is a default
> -        definition.  There's little to be gained by trying to handle that.  */
> -      if (def_code == SSA_NAME
> -         && !SSA_NAME_IS_DEFAULT_DEF (gimple_assign_rhs1 (stmt)))
> -       return true;
> -
> -      /* If the RHS is a constant, then it's a terminal that we'll want
> -        to handle as well.  */
> -      if (TREE_CODE_CLASS (def_code) == tcc_constant)
> -       return true;
> -    }
> -
> -  /* Anything not explicitly allowed is not handled.  */
> -  return false;
> -}
> -
> -/* Given STMT which defines NAME in block DEF_BB, recurse through the
> -   PHI's arguments searching for paths where NAME will ultimately have
> -   a constant value.
> -
> -   PATH contains the series of blocks to traverse that will result in
> -   NAME having a constant value.  */
> -
> -void
> -thread_jumps::handle_assignment (gimple *stmt, basic_block def_bb)
> -{
> -  tree arg = gimple_assign_rhs1 (stmt);
> -
> -  if (TREE_CODE (arg) == SSA_NAME)
> -    fsm_find_control_statement_thread_paths (arg);
> -  else
> -    {
> -      if (CHECKING_P)
> -       {
> -         gcc_assert (!m_path.is_empty ());
> -         basic_block top = m_path[m_path.length () - 1];
> -         gcc_assert (top == def_bb);
> -       }
> -      edge taken_edge = find_taken_edge (m_path, arg);
> -      if (taken_edge)
> -       maybe_register_path (m_path, m_name, taken_edge);
> -    }
> -}
> -
> -/* We trace the value of the SSA_NAME NAME back through any phi nodes
> -   looking for places where it gets a constant value and save the
> -   path.  */
> -
> -void
> -thread_jumps::fsm_find_control_statement_thread_paths (tree name)
> -{
> -  /* If NAME appears in an abnormal PHI, then don't try to trace its
> -     value back through PHI nodes.  */
> -  if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
> -    return;
> -
> -  gimple *def_stmt = SSA_NAME_DEF_STMT (name);
> -  basic_block def_bb = gimple_bb (def_stmt);
> -
> -  if (def_bb == NULL)
> -    return;
> -
> -  /* We allow the SSA chain to contains PHIs and simple copies and constant
> -     initializations.  */
> -  if (gimple_code (def_stmt) != GIMPLE_PHI
> -      && gimple_code (def_stmt) != GIMPLE_ASSIGN)
> -    return;
> -
> -  if (gimple_code (def_stmt) == GIMPLE_PHI
> -      && (gimple_phi_num_args (def_stmt)
> -         >= (unsigned) param_fsm_maximum_phi_arguments))
> -    return;
> -
> -  if (is_gimple_assign (def_stmt)
> -      && ! handle_assignment_p (def_stmt))
> -    return;
> -
> -  /* Avoid infinite recursion.  */
> -  if (m_visited_bbs.add (def_bb))
> -    return;
> -
> -  int next_path_length = 0;
> -  basic_block last_bb_in_path = m_path.last ();
> -
> -  if (loop_containing_stmt (def_stmt)->header == gimple_bb (def_stmt))
> -    {
> -      /* Do not walk through more than one loop PHI node.  */
> -      if (m_seen_loop_phi)
> -       return;
> -      m_seen_loop_phi = true;
> -    }
> -
> -  /* Following the chain of SSA_NAME definitions, we jumped from a definition in
> -     LAST_BB_IN_PATH to a definition in DEF_BB.  When these basic blocks are
> -     different, append to PATH the blocks from LAST_BB_IN_PATH to DEF_BB.  */
> -  if (def_bb != last_bb_in_path)
> -    {
> -      /* When DEF_BB == LAST_BB_IN_PATH, then the first block in the path
> -        will already be in VISITED_BBS.  When they are not equal, then we
> -        must ensure that first block is accounted for to ensure we do not
> -        create bogus jump threading paths.  */
> -      m_visited_bbs.add (m_path[0]);
> -      if (!check_subpath_and_update_thread_path (last_bb_in_path, def_bb,
> -                                                &next_path_length))
> -       return;
> -    }
> -
> -  gcc_assert (m_path.last () == def_bb);
> -
> -  if (gimple_code (def_stmt) == GIMPLE_PHI)
> -    handle_phi (as_a <gphi *> (def_stmt), def_bb);
> -  else if (gimple_code (def_stmt) == GIMPLE_ASSIGN)
> -    handle_assignment (def_stmt, def_bb);
> -
> -  /* Remove all the nodes that we added from NEXT_PATH.  */
> -  if (next_path_length)
> -    m_path.truncate (m_path.length () - next_path_length);
> -}
> -
> -/* Search backwards from BB looking for paths where NAME (an SSA_NAME)
> -   is a constant.  Record such paths for jump threading.
> -
> -   It is assumed that BB ends with a control statement and that by
> -   finding a path where NAME is a constant, we can thread the path.
> -   SPEED_P indicates that we could increase code size to improve the
> -   code path.  */
> -
> -void
> -thread_jumps::find_jump_threads_backwards (basic_block bb)
> -{
> -  if (param_threader_mode & THREADER_MODE_RANGER)
> -    {
> -      find_jump_threads_backwards_with_ranger (bb);
> -      return;
> -    }
> -
> -  gimple *stmt = get_gimple_control_stmt (bb);
> -  if (!stmt)
> -    return;
> -
> -  enum gimple_code code = gimple_code (stmt);
> -  tree name = NULL;
> -  if (code == GIMPLE_SWITCH)
> -    name = gimple_switch_index (as_a <gswitch *> (stmt));
> -  else if (code == GIMPLE_GOTO)
> -    name = gimple_goto_dest (stmt);
> -  else if (code == GIMPLE_COND)
> -    {
> -      if (TREE_CODE (gimple_cond_lhs (stmt)) == SSA_NAME
> -         && TREE_CODE_CLASS (TREE_CODE (gimple_cond_rhs (stmt))) == tcc_constant
> -         && (INTEGRAL_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))
> -             || POINTER_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))))
> -       name = gimple_cond_lhs (stmt);
> -    }
> -
> -  if (!name || TREE_CODE (name) != SSA_NAME)
> -    return;
> -
> -  /* Initialize pass local data that's different for each BB.  */
> -  m_path.truncate (0);
> -  m_path.safe_push (bb);
> -  m_visited_bbs.empty ();
> -  m_seen_loop_phi = false;
> -  m_name = name;
> -
> -  fsm_find_control_statement_thread_paths (name);
> -}
> -
> -// Like find_jump_threads_backwards(), but using ranger.
> -
> -void
> -thread_jumps::find_jump_threads_backwards_with_ranger (basic_block bb)
> -{
> -  gimple *stmt = get_gimple_control_stmt (bb);
> -  if (!stmt)
> -    return;
> -
> -  enum gimple_code code = gimple_code (stmt);
> -  tree name = NULL;
> -  if (code == GIMPLE_SWITCH)
> -    name = gimple_switch_index (as_a <gswitch *> (stmt));
> -  else if (code == GIMPLE_GOTO)
> -    name = gimple_goto_dest (stmt);
> -  else if (code == GIMPLE_COND)
> -    name = gimple_cond_lhs (stmt);
> -
> -  m_name = name;
> -  m_back_threader.find_paths (bb, name);
> -}
> -
>  namespace {
>
>  const pass_data pass_data_thread_jumps =
> @@ -1327,12 +908,12 @@ static bool
>  try_thread_blocks (function *fun)
>  {
>    /* Try to thread each block with more than one successor.  */
> -  thread_jumps threader;
> +  back_threader threader (/*speed_p=*/true);
>    basic_block bb;
>    FOR_EACH_BB_FN (bb, fun)
>      {
>        if (EDGE_COUNT (bb->succs) > 1)
> -       threader.find_jump_threads_backwards (bb);
> +       threader.maybe_thread (bb);
>      }
>    return threader.thread_through_all_blocks ();
>  }
> @@ -1397,12 +978,12 @@ pass_early_thread_jumps::execute (function *fun)
>    loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
>
>    /* Try to thread each block with more than one successor.  */
> -  thread_jumps threader (/*speed_p=*/false);
> +  back_threader threader (/*speed_p=*/false);
>    basic_block bb;
>    FOR_EACH_BB_FN (bb, fun)
>      {
>        if (EDGE_COUNT (bb->succs) > 1)
> -       threader.find_jump_threads_backwards (bb);
> +       threader.maybe_thread (bb);
>      }
>    threader.thread_through_all_blocks ();
>
> --
> 2.31.1
>



More information about the Gcc-patches mailing list