/* Thread edges through blocks and update the control flow and SSA graphs.
- Copyright (C) 2004-2013 Free Software Foundation, Inc.
+ Copyright (C) 2004-2014 Free Software Foundation, Inc.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
#include "tree.h"
#include "flags.h"
-#include "tm_p.h"
-#include "basic-block.h"
+#include "predict.h"
+#include "vec.h"
+#include "hashtab.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "tm.h"
+#include "hard-reg-set.h"
+#include "input.h"
#include "function.h"
-#include "tree-flow.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "cfganal.h"
+#include "basic-block.h"
+#include "hash-table.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "gimple-iterator.h"
+#include "gimple-ssa.h"
+#include "tree-phinodes.h"
+#include "tree-ssa.h"
+#include "tree-ssa-threadupdate.h"
+#include "ssa-iterators.h"
#include "dumpfile.h"
#include "cfgloop.h"
-#include "hash-table.h"
+#include "dbgcnt.h"
+#include "tree-cfg.h"
+#include "tree-pass.h"
/* Given a block B, update the CFG and SSA graph to reflect redirecting
one or more in-edges to B to instead reach the destination of an
set of unique destination blocks that the incoming edges should
be threaded to.
- Block duplication can be further minimized by using B instead of
- creating B' for one destination if all edges into B are going to be
- threaded to a successor of B. We had code to do this at one time, but
- I'm not convinced it is correct with the changes to avoid mucking up
- the loop structure (which may cancel threading requests, thus a block
- which we thought was going to become unreachable may still be reachable).
- This code was also going to get ugly with the introduction of the ability
- for a single jump thread request to bypass multiple blocks.
+ We reduce the number of edges and statements we create by not copying all
+ the outgoing edges and the control statement in step #1. We instead create
+ a template block without the outgoing edges and duplicate the template.
- We further reduce the number of edges and statements we create by
- not copying all the outgoing edges and the control statement in
- step #1. We instead create a template block without the outgoing
- edges and duplicate the template. */
+ Another case this code handles is threading through a "joiner" block. In
+ this case, we do not know the destination of the joiner block, but one
+ of the outgoing edges from the joiner block leads to a threadable path. This
+ case largely works as outlined above, except the duplicate of the joiner
+ block still contains a full set of outgoing edges and its control statement.
+ We just redirect one of its outgoing edges to our jump threading path. */
/* Steps #5 and #6 of the above algorithm are best implemented by walking
struct redirection_data : typed_free_remove<redirection_data>
{
- /* A duplicate of B with the trailing control statement removed and which
- targets a single successor of B. */
- basic_block dup_block;
+ /* We support wiring up two block duplicates in a jump threading path.
- /* An outgoing edge from B. DUP_BLOCK will have OUTGOING_EDGE->dest as
- its single successor. */
- edge outgoing_edge;
+ One is a normal block copy where we remove the control statement
+ and wire up its single remaining outgoing edge to the thread path.
- edge intermediate_edge;
+ The other is a joiner block where we leave the control statement
+ in place, but wire one of the outgoing edges to a thread path.
- /* A list of incoming edges which we want to thread to
- OUTGOING_EDGE->dest. */
+ In theory we could have multiple block duplicates in a jump
+ threading path, but I haven't tried that.
+
+ The duplicate blocks appear in this array in the same order in
+ which they appear in the jump thread path. */
+ basic_block dup_blocks[2];
+
+ /* The jump threading path. */
+ vec<jump_thread_edge *> *path;
+
+ /* A list of incoming edges which we want to thread to the
+ same path. */
struct el *incoming_edges;
/* hash_table support. */
static inline int equal (const value_type *, const compare_type *);
};
+/* Dump a jump threading path, including annotations about each
+ edge in the path. */
+
+static void
+dump_jump_thread_path (FILE *dump_file, vec<jump_thread_edge *> path,
+ bool registering)
+{
+ fprintf (dump_file,
+ " %s jump thread: (%d, %d) incoming edge; ",
+ (registering ? "Registering" : "Cancelling"),
+ path[0]->e->src->index, path[0]->e->dest->index);
+
+ for (unsigned int i = 1; i < path.length (); i++)
+ {
+ /* We can get paths with a NULL edge when the final destination
+ of a jump thread turns out to be a constant address. We dump
+ those paths when debugging, so we have to be prepared for that
+ possibility here. */
+ if (path[i]->e == NULL)
+ continue;
+
+ if (path[i]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ fprintf (dump_file, " (%d, %d) joiner; ",
+ path[i]->e->src->index, path[i]->e->dest->index);
+ if (path[i]->type == EDGE_COPY_SRC_BLOCK)
+ fprintf (dump_file, " (%d, %d) normal;",
+ path[i]->e->src->index, path[i]->e->dest->index);
+ if (path[i]->type == EDGE_NO_COPY_SRC_BLOCK)
+ fprintf (dump_file, " (%d, %d) nocopy;",
+ path[i]->e->src->index, path[i]->e->dest->index);
+ }
+ fputc ('\n', dump_file);
+}
+
+/* Simple hashing function. For any given incoming edge E, we're going
+ to be most concerned with the final destination of its jump thread
+ path. So hash on the block index of the final edge in the path. */
+
inline hashval_t
redirection_data::hash (const value_type *p)
{
- edge e = p->outgoing_edge;
- return e->dest->index;
+ vec<jump_thread_edge *> *path = p->path;
+ return path->last ()->e->dest->index;
}
+/* Given two hash table entries, return true if they have the same
+ jump threading path. */
inline int
redirection_data::equal (const value_type *p1, const compare_type *p2)
{
- edge e1 = p1->outgoing_edge;
- edge e2 = p2->outgoing_edge;
- edge e3 = p1->intermediate_edge;
- edge e4 = p2->intermediate_edge;
- return e1 == e2 && e3 == e4;
+ vec<jump_thread_edge *> *path1 = p1->path;
+ vec<jump_thread_edge *> *path2 = p2->path;
+
+ if (path1->length () != path2->length ())
+ return false;
+
+ for (unsigned int i = 1; i < path1->length (); i++)
+ {
+ if ((*path1)[i]->type != (*path2)[i]->type
+ || (*path1)[i]->e != (*path2)[i]->e)
+ return false;
+ }
+
+ return true;
}
/* Data structure of information to pass to hash table traversal routines. */
/* The current block we are working on. */
basic_block bb;
- /* A template copy of BB with no outgoing edges or control statement that
- we use for creating copies. */
+ /* We only create a template block for the first duplicated block in a
+ jump threading path as we may need many duplicates of that block.
+
+ The second duplicate block in a path is specific to that path. Creating
+ and sharing a template for that block is considerably more difficult. */
basic_block template_block;
/* TRUE if we thread one or more jumps, FALSE otherwise. */
bool jumps_threaded;
+
+ /* Blocks duplicated for the thread. */
+ bitmap duplicate_blocks;
};
/* Passes which use the jump threading code register jump threading
opportunities as they are discovered. We keep the registered
jump threading opportunities in this vector as edge pairs
(original_edge, target_edge). */
-static vec<edge> threaded_edges;
+static vec<vec<jump_thread_edge *> *> paths;
/* When we start updating the CFG for threading, data necessary for jump
threading is attached to the AUX field for the incoming edge. Use these
macros to access the underlying structure attached to the AUX field. */
-#define THREAD_TARGET(E) ((edge *)(E)->aux)[0]
-#define THREAD_TARGET2(E) ((edge *)(E)->aux)[1]
+#define THREAD_PATH(E) ((vec<jump_thread_edge *> *)(E)->aux)
/* Jump threading statistics. */
}
}
-/* Create a duplicate of BB. Record the duplicate block in RD. */
+/* Create a duplicate of BB. Record the duplicate block in an array
+ indexed by COUNT stored in RD. */
static void
-create_block_for_threading (basic_block bb, struct redirection_data *rd)
+create_block_for_threading (basic_block bb,
+ struct redirection_data *rd,
+ unsigned int count,
+ bitmap *duplicate_blocks)
{
edge_iterator ei;
edge e;
/* We can use the generic block duplication code and simply remove
the stuff we do not need. */
- rd->dup_block = duplicate_block (bb, NULL, NULL);
+ rd->dup_blocks[count] = duplicate_block (bb, NULL, NULL);
- FOR_EACH_EDGE (e, ei, rd->dup_block->succs)
+ FOR_EACH_EDGE (e, ei, rd->dup_blocks[count]->succs)
e->aux = NULL;
/* Zero out the profile, since the block is unreachable for now. */
- rd->dup_block->frequency = 0;
- rd->dup_block->count = 0;
+ rd->dup_blocks[count]->frequency = 0;
+ rd->dup_blocks[count]->count = 0;
+ if (duplicate_blocks)
+ bitmap_set_bit (*duplicate_blocks, rd->dup_blocks[count]->index);
}
/* Main data structure to hold information for duplicates of BB. */
-static hash_table <redirection_data> redirection_data;
+static hash_table<redirection_data> *redirection_data;
/* Given an outgoing edge E lookup and return its entry in our hash table.
{
struct redirection_data **slot;
struct redirection_data *elt;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
/* Build a hash table element so we can see if E is already
in the table. */
elt = XNEW (struct redirection_data);
- elt->intermediate_edge = THREAD_TARGET2 (e) ? THREAD_TARGET (e) : NULL;
- elt->outgoing_edge = THREAD_TARGET2 (e) ? THREAD_TARGET2 (e)
- : THREAD_TARGET (e);
- elt->dup_block = NULL;
+ elt->path = path;
+ elt->dup_blocks[0] = NULL;
+ elt->dup_blocks[1] = NULL;
elt->incoming_edges = NULL;
- slot = redirection_data.find_slot (elt, insert);
+ slot = redirection_data->find_slot (elt, insert);
/* This will only happen if INSERT is false and the entry is not
in the hash table. */
to the list of incoming edges associated with E. */
if (insert)
{
- struct el *el = XNEW (struct el);
+ struct el *el = XNEW (struct el);
el->next = elt->incoming_edges;
el->e = e;
elt->incoming_edges = el;
}
}
-/* For each PHI in BB, copy the argument associated with SRC_E to TGT_E. */
+/* Similar to copy_phi_args, except that the PHI arg exists, it just
+ does not have a value associated with it. */
static void
-copy_phi_args (basic_block bb, edge src_e, edge tgt_e)
+copy_phi_arg_into_existing_phi (edge src_e, edge tgt_e)
{
- gimple_stmt_iterator gsi;
+ int src_idx = src_e->dest_idx;
+ int tgt_idx = tgt_e->dest_idx;
+
+ /* Iterate over each PHI in e->dest. */
+ for (gphi_iterator gsi = gsi_start_phis (src_e->dest),
+ gsi2 = gsi_start_phis (tgt_e->dest);
+ !gsi_end_p (gsi);
+ gsi_next (&gsi), gsi_next (&gsi2))
+ {
+ gphi *src_phi = gsi.phi ();
+ gphi *dest_phi = gsi2.phi ();
+ tree val = gimple_phi_arg_def (src_phi, src_idx);
+ source_location locus = gimple_phi_arg_location (src_phi, src_idx);
+
+ SET_PHI_ARG_DEF (dest_phi, tgt_idx, val);
+ gimple_phi_arg_set_location (dest_phi, tgt_idx, locus);
+ }
+}
+
+/* Given ssa_name DEF, backtrack jump threading PATH from node IDX
+ to see if it has constant value in a flow sensitive manner. Set
+ LOCUS to location of the constant phi arg and return the value.
+ Return DEF directly if either PATH or idx is ZERO. */
+
+static tree
+get_value_locus_in_path (tree def, vec<jump_thread_edge *> *path,
+ basic_block bb, int idx, source_location *locus)
+{
+ tree arg;
+ gphi *def_phi;
+ basic_block def_bb;
+
+ if (path == NULL || idx == 0)
+ return def;
+
+ def_phi = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (def));
+ if (!def_phi)
+ return def;
+
+ def_bb = gimple_bb (def_phi);
+ /* Don't propagate loop invariants into deeper loops. */
+ if (!def_bb || bb_loop_depth (def_bb) < bb_loop_depth (bb))
+ return def;
+
+ /* Backtrack jump threading path from IDX to see if def has constant
+ value. */
+ for (int j = idx - 1; j >= 0; j--)
+ {
+ edge e = (*path)[j]->e;
+ if (e->dest == def_bb)
+ {
+ arg = gimple_phi_arg_def (def_phi, e->dest_idx);
+ if (is_gimple_min_invariant (arg))
+ {
+ *locus = gimple_phi_arg_location (def_phi, e->dest_idx);
+ return arg;
+ }
+ break;
+ }
+ }
+
+ return def;
+}
+
+/* For each PHI in BB, copy the argument associated with SRC_E to TGT_E.
+ Try to backtrack jump threading PATH from node IDX to see if the arg
+ has constant value, copy constant value instead of argument itself
+ if yes. */
+
+static void
+copy_phi_args (basic_block bb, edge src_e, edge tgt_e,
+ vec<jump_thread_edge *> *path, int idx)
+{
+ gphi_iterator gsi;
int src_indx = src_e->dest_idx;
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple phi = gsi_stmt (gsi);
+ gphi *phi = gsi.phi ();
+ tree def = gimple_phi_arg_def (phi, src_indx);
source_location locus = gimple_phi_arg_location (phi, src_indx);
- add_phi_arg (phi, gimple_phi_arg_def (phi, src_indx), tgt_e, locus);
+
+ if (TREE_CODE (def) == SSA_NAME
+ && !virtual_operand_p (gimple_phi_result (phi)))
+ def = get_value_locus_in_path (def, path, bb, idx, &locus);
+
+ add_phi_arg (phi, def, tgt_e, locus);
}
}
edges. The copy is NEW_BB. Every PHI node in every direct successor of
ORIG_BB has a new argument associated with edge from NEW_BB to the
successor. Initialize the PHI argument so that it is equal to the PHI
- argument associated with the edge from ORIG_BB to the successor. */
+ argument associated with the edge from ORIG_BB to the successor.
+ PATH and IDX are used to check if the new PHI argument has constant
+ value in a flow sensitive manner. */
static void
-update_destination_phis (basic_block orig_bb, basic_block new_bb)
+update_destination_phis (basic_block orig_bb, basic_block new_bb,
+ vec<jump_thread_edge *> *path, int idx)
{
edge_iterator ei;
edge e;
FOR_EACH_EDGE (e, ei, orig_bb->succs)
{
edge e2 = find_edge (new_bb, e->dest);
- copy_phi_args (e->dest, e, e2);
+ copy_phi_args (e->dest, e, e2, path, idx);
}
}
destination.
Add an additional argument to any PHI nodes at the single
- destination. */
+ destination. IDX is the start node in jump threading path
+ we start to check to see if the new PHI argument has constant
+ value along the jump threading path. */
static void
create_edge_and_update_destination_phis (struct redirection_data *rd,
- basic_block bb)
+ basic_block bb, int idx)
{
- edge e = make_edge (bb, rd->outgoing_edge->dest, EDGE_FALLTHRU);
+ edge e = make_edge (bb, rd->path->last ()->e->dest, EDGE_FALLTHRU);
rescan_loop_exit (e, true, false);
e->probability = REG_BR_PROB_BASE;
e->count = bb->count;
- if (rd->outgoing_edge->aux)
- {
- e->aux = XNEWVEC (edge, 2);
- THREAD_TARGET(e) = THREAD_TARGET (rd->outgoing_edge);
- THREAD_TARGET2(e) = THREAD_TARGET2 (rd->outgoing_edge);
- }
- else
- {
- e->aux = NULL;
- }
+ /* We used to copy the thread path here. That was added in 2007
+ and dutifully updated through the representation changes in 2013.
+
+ In 2013 we added code to thread from an interior node through
+ the backedge to another interior node. That runs after the code
+ to thread through loop headers from outside the loop.
+
+ The latter may delete edges in the CFG, including those
+ which appeared in the jump threading path we copied here. Thus
+ we'd end up using a dangling pointer.
+
+ After reviewing the 2007/2011 code, I can't see how anything
+ depended on copying the AUX field and clearly copying the jump
+ threading path is problematical due to embedded edge pointers.
+ It has been removed. */
+ e->aux = NULL;
/* If there are any PHI nodes at the destination of the outgoing edge
from the duplicate block, then we will need to add a new argument
to them. The argument should have the same value as the argument
associated with the outgoing edge stored in RD. */
- copy_phi_args (e->dest, rd->outgoing_edge, e);
+ copy_phi_args (e->dest, rd->path->last ()->e, e, rd->path, idx);
+}
+
+/* Look through PATH beginning at START and return TRUE if there are
+ any additional blocks that need to be duplicated. Otherwise,
+ return FALSE. */
+static bool
+any_remaining_duplicated_blocks (vec<jump_thread_edge *> *path,
+ unsigned int start)
+{
+ for (unsigned int i = start + 1; i < path->length (); i++)
+ {
+ if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK
+ || (*path)[i]->type == EDGE_COPY_SRC_BLOCK)
+ return true;
+ }
+ return false;
+}
+
+
+/* Compute the amount of profile count/frequency coming into the jump threading
+ path stored in RD that we are duplicating, returned in PATH_IN_COUNT_PTR and
+ PATH_IN_FREQ_PTR, as well as the amount of counts flowing out of the
+ duplicated path, returned in PATH_OUT_COUNT_PTR. LOCAL_INFO is used to
+ identify blocks duplicated for jump threading, which have duplicated
+ edges that need to be ignored in the analysis. Return true if path contains
+ a joiner, false otherwise.
+
+ In the non-joiner case, this is straightforward - all the counts/frequency
+ flowing into the jump threading path should flow through the duplicated
+ block and out of the duplicated path.
+
+ In the joiner case, it is very tricky. Some of the counts flowing into
+ the original path go offpath at the joiner. The problem is that while
+ we know how much total count goes off-path in the original control flow,
+ we don't know how many of the counts corresponding to just the jump
+ threading path go offpath at the joiner.
+
+ For example, assume we have the following control flow and identified
+ jump threading paths:
+
+ A B C
+ \ | /
+ Ea \ |Eb / Ec
+ \ | /
+ v v v
+ J <-- Joiner
+ / \
+ Eoff/ \Eon
+ / \
+ v v
+ Soff Son <--- Normal
+ /\
+ Ed/ \ Ee
+ / \
+ v v
+ D E
+
+ Jump threading paths: A -> J -> Son -> D (path 1)
+ C -> J -> Son -> E (path 2)
+
+ Note that the control flow could be more complicated:
+ - Each jump threading path may have more than one incoming edge. I.e. A and
+ Ea could represent multiple incoming blocks/edges that are included in
+ path 1.
+ - There could be EDGE_NO_COPY_SRC_BLOCK edges after the joiner (either
+ before or after the "normal" copy block). These are not duplicated onto
+ the jump threading path, as they are single-successor.
+ - Any of the blocks along the path may have other incoming edges that
+ are not part of any jump threading path, but add profile counts along
+ the path.
+
+ In the aboe example, after all jump threading is complete, we will
+ end up with the following control flow:
+
+ A B C
+ | | |
+ Ea| |Eb |Ec
+ | | |
+ v v v
+ Ja J Jc
+ / \ / \Eon' / \
+ Eona/ \ ---/---\-------- \Eonc
+ / \ / / \ \
+ v v v v v
+ Sona Soff Son Sonc
+ \ /\ /
+ \___________ / \ _____/
+ \ / \/
+ vv v
+ D E
+
+ The main issue to notice here is that when we are processing path 1
+ (A->J->Son->D) we need to figure out the outgoing edge weights to
+ the duplicated edges Ja->Sona and Ja->Soff, while ensuring that the
+ sum of the incoming weights to D remain Ed. The problem with simply
+ assuming that Ja (and Jc when processing path 2) has the same outgoing
+ probabilities to its successors as the original block J, is that after
+ all paths are processed and other edges/counts removed (e.g. none
+ of Ec will reach D after processing path 2), we may end up with not
+ enough count flowing along duplicated edge Sona->D.
+
+ Therefore, in the case of a joiner, we keep track of all counts
+ coming in along the current path, as well as from predecessors not
+ on any jump threading path (Eb in the above example). While we
+ first assume that the duplicated Eona for Ja->Sona has the same
+ probability as the original, we later compensate for other jump
+ threading paths that may eliminate edges. We do that by keep track
+ of all counts coming into the original path that are not in a jump
+ thread (Eb in the above example, but as noted earlier, there could
+ be other predecessors incoming to the path at various points, such
+ as at Son). Call this cumulative non-path count coming into the path
+ before D as Enonpath. We then ensure that the count from Sona->D is as at
+ least as big as (Ed - Enonpath), but no bigger than the minimum
+ weight along the jump threading path. The probabilities of both the
+ original and duplicated joiner block J and Ja will be adjusted
+ accordingly after the updates. */
+
+static bool
+compute_path_counts (struct redirection_data *rd,
+ ssa_local_info_t *local_info,
+ gcov_type *path_in_count_ptr,
+ gcov_type *path_out_count_ptr,
+ int *path_in_freq_ptr)
+{
+ edge e = rd->incoming_edges->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge elast = path->last ()->e;
+ gcov_type nonpath_count = 0;
+ bool has_joiner = false;
+ gcov_type path_in_count = 0;
+ int path_in_freq = 0;
+
+ /* Start by accumulating incoming edge counts to the path's first bb
+ into a couple buckets:
+ path_in_count: total count of incoming edges that flow into the
+ current path.
+ nonpath_count: total count of incoming edges that are not
+ flowing along *any* path. These are the counts
+ that will still flow along the original path after
+ all path duplication is done by potentially multiple
+ calls to this routine.
+ (any other incoming edge counts are for a different jump threading
+ path that will be handled by a later call to this routine.)
+ To make this easier, start by recording all incoming edges that flow into
+ the current path in a bitmap. We could add up the path's incoming edge
+ counts here, but we still need to walk all the first bb's incoming edges
+ below to add up the counts of the other edges not included in this jump
+ threading path. */
+ struct el *next, *el;
+ bitmap in_edge_srcs = BITMAP_ALLOC (NULL);
+ for (el = rd->incoming_edges; el; el = next)
+ {
+ next = el->next;
+ bitmap_set_bit (in_edge_srcs, el->e->src->index);
+ }
+ edge ein;
+ edge_iterator ei;
+ FOR_EACH_EDGE (ein, ei, e->dest->preds)
+ {
+ vec<jump_thread_edge *> *ein_path = THREAD_PATH (ein);
+ /* Simply check the incoming edge src against the set captured above. */
+ if (ein_path
+ && bitmap_bit_p (in_edge_srcs, (*ein_path)[0]->e->src->index))
+ {
+ /* It is necessary but not sufficient that the last path edges
+ are identical. There may be different paths that share the
+ same last path edge in the case where the last edge has a nocopy
+ source block. */
+ gcc_assert (ein_path->last ()->e == elast);
+ path_in_count += ein->count;
+ path_in_freq += EDGE_FREQUENCY (ein);
+ }
+ else if (!ein_path)
+ {
+ /* Keep track of the incoming edges that are not on any jump-threading
+ path. These counts will still flow out of original path after all
+ jump threading is complete. */
+ nonpath_count += ein->count;
+ }
+ }
+
+ /* This is needed due to insane incoming frequencies. */
+ if (path_in_freq > BB_FREQ_MAX)
+ path_in_freq = BB_FREQ_MAX;
+
+ BITMAP_FREE (in_edge_srcs);
+
+ /* Now compute the fraction of the total count coming into the first
+ path bb that is from the current threading path. */
+ gcov_type total_count = e->dest->count;
+ /* Handle incoming profile insanities. */
+ if (total_count < path_in_count)
+ path_in_count = total_count;
+ int onpath_scale = GCOV_COMPUTE_SCALE (path_in_count, total_count);
+
+ /* Walk the entire path to do some more computation in order to estimate
+ how much of the path_in_count will flow out of the duplicated threading
+ path. In the non-joiner case this is straightforward (it should be
+ the same as path_in_count, although we will handle incoming profile
+ insanities by setting it equal to the minimum count along the path).
+
+ In the joiner case, we need to estimate how much of the path_in_count
+ will stay on the threading path after the joiner's conditional branch.
+ We don't really know for sure how much of the counts
+ associated with this path go to each successor of the joiner, but we'll
+ estimate based on the fraction of the total count coming into the path
+ bb was from the threading paths (computed above in onpath_scale).
+ Afterwards, we will need to do some fixup to account for other threading
+ paths and possible profile insanities.
+
+ In order to estimate the joiner case's counts we also need to update
+ nonpath_count with any additional counts coming into the path. Other
+ blocks along the path may have additional predecessors from outside
+ the path. */
+ gcov_type path_out_count = path_in_count;
+ gcov_type min_path_count = path_in_count;
+ for (unsigned int i = 1; i < path->length (); i++)
+ {
+ edge epath = (*path)[i]->e;
+ gcov_type cur_count = epath->count;
+ if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ has_joiner = true;
+ cur_count = apply_probability (cur_count, onpath_scale);
+ }
+ /* In the joiner case we need to update nonpath_count for any edges
+ coming into the path that will contribute to the count flowing
+ into the path successor. */
+ if (has_joiner && epath != elast)
+ {
+ /* Look for other incoming edges after joiner. */
+ FOR_EACH_EDGE (ein, ei, epath->dest->preds)
+ {
+ if (ein != epath
+ /* Ignore in edges from blocks we have duplicated for a
+ threading path, which have duplicated edge counts until
+ they are redirected by an invocation of this routine. */
+ && !bitmap_bit_p (local_info->duplicate_blocks,
+ ein->src->index))
+ nonpath_count += ein->count;
+ }
+ }
+ if (cur_count < path_out_count)
+ path_out_count = cur_count;
+ if (epath->count < min_path_count)
+ min_path_count = epath->count;
+ }
+
+ /* We computed path_out_count above assuming that this path targeted
+ the joiner's on-path successor with the same likelihood as it
+ reached the joiner. However, other thread paths through the joiner
+ may take a different path through the normal copy source block
+ (i.e. they have a different elast), meaning that they do not
+ contribute any counts to this path's elast. As a result, it may
+ turn out that this path must have more count flowing to the on-path
+ successor of the joiner. Essentially, all of this path's elast
+ count must be contributed by this path and any nonpath counts
+ (since any path through the joiner with a different elast will not
+ include a copy of this elast in its duplicated path).
+ So ensure that this path's path_out_count is at least the
+ difference between elast->count and nonpath_count. Otherwise the edge
+ counts after threading will not be sane. */
+ if (has_joiner && path_out_count < elast->count - nonpath_count)
+ {
+ path_out_count = elast->count - nonpath_count;
+ /* But neither can we go above the minimum count along the path
+ we are duplicating. This can be an issue due to profile
+ insanities coming in to this pass. */
+ if (path_out_count > min_path_count)
+ path_out_count = min_path_count;
+ }
+
+ *path_in_count_ptr = path_in_count;
+ *path_out_count_ptr = path_out_count;
+ *path_in_freq_ptr = path_in_freq;
+ return has_joiner;
+}
+
+
+/* Update the counts and frequencies for both an original path
+ edge EPATH and its duplicate EDUP. The duplicate source block
+ will get a count/frequency of PATH_IN_COUNT and PATH_IN_FREQ,
+ and the duplicate edge EDUP will have a count of PATH_OUT_COUNT. */
+static void
+update_profile (edge epath, edge edup, gcov_type path_in_count,
+ gcov_type path_out_count, int path_in_freq)
+{
+
+ /* First update the duplicated block's count / frequency. */
+ if (edup)
+ {
+ basic_block dup_block = edup->src;
+ gcc_assert (dup_block->count == 0);
+ gcc_assert (dup_block->frequency == 0);
+ dup_block->count = path_in_count;
+ dup_block->frequency = path_in_freq;
+ }
+
+ /* Now update the original block's count and frequency in the
+ opposite manner - remove the counts/freq that will flow
+ into the duplicated block. Handle underflow due to precision/
+ rounding issues. */
+ epath->src->count -= path_in_count;
+ if (epath->src->count < 0)
+ epath->src->count = 0;
+ epath->src->frequency -= path_in_freq;
+ if (epath->src->frequency < 0)
+ epath->src->frequency = 0;
+
+ /* Next update this path edge's original and duplicated counts. We know
+ that the duplicated path will have path_out_count flowing
+ out of it (in the joiner case this is the count along the duplicated path
+ out of the duplicated joiner). This count can then be removed from the
+ original path edge. */
+ if (edup)
+ edup->count = path_out_count;
+ epath->count -= path_out_count;
+ gcc_assert (epath->count >= 0);
+}
+
+
+/* The duplicate and original joiner blocks may end up with different
+ probabilities (different from both the original and from each other).
+ Recompute the probabilities here once we have updated the edge
+ counts and frequencies. */
+
+static void
+recompute_probabilities (basic_block bb)
+{
+ edge esucc;
+ edge_iterator ei;
+ FOR_EACH_EDGE (esucc, ei, bb->succs)
+ {
+ if (!bb->count)
+ continue;
+
+ /* Prevent overflow computation due to insane profiles. */
+ if (esucc->count < bb->count)
+ esucc->probability = GCOV_COMPUTE_SCALE (esucc->count,
+ bb->count);
+ else
+ /* Can happen with missing/guessed probabilities, since we
+ may determine that more is flowing along duplicated
+ path than joiner succ probabilities allowed.
+ Counts and freqs will be insane after jump threading,
+ at least make sure probability is sane or we will
+ get a flow verification error.
+ Not much we can do to make counts/freqs sane without
+ redoing the profile estimation. */
+ esucc->probability = REG_BR_PROB_BASE;
+ }
+}
+
+
+/* Update the counts of the original and duplicated edges from a joiner
+ that go off path, given that we have already determined that the
+ duplicate joiner DUP_BB has incoming count PATH_IN_COUNT and
+ outgoing count along the path PATH_OUT_COUNT. The original (on-)path
+ edge from joiner is EPATH. */
+
+static void
+update_joiner_offpath_counts (edge epath, basic_block dup_bb,
+ gcov_type path_in_count,
+ gcov_type path_out_count)
+{
+ /* Compute the count that currently flows off path from the joiner.
+ In other words, the total count of joiner's out edges other than
+ epath. Compute this by walking the successors instead of
+ subtracting epath's count from the joiner bb count, since there
+ are sometimes slight insanities where the total out edge count is
+ larger than the bb count (possibly due to rounding/truncation
+ errors). */
+ gcov_type total_orig_off_path_count = 0;
+ edge enonpath;
+ edge_iterator ei;
+ FOR_EACH_EDGE (enonpath, ei, epath->src->succs)
+ {
+ if (enonpath == epath)
+ continue;
+ total_orig_off_path_count += enonpath->count;
+ }
+
+ /* For the path that we are duplicating, the amount that will flow
+ off path from the duplicated joiner is the delta between the
+ path's cumulative in count and the portion of that count we
+ estimated above as flowing from the joiner along the duplicated
+ path. */
+ gcov_type total_dup_off_path_count = path_in_count - path_out_count;
+
+ /* Now do the actual updates of the off-path edges. */
+ FOR_EACH_EDGE (enonpath, ei, epath->src->succs)
+ {
+ /* Look for edges going off of the threading path. */
+ if (enonpath == epath)
+ continue;
+
+ /* Find the corresponding edge out of the duplicated joiner. */
+ edge enonpathdup = find_edge (dup_bb, enonpath->dest);
+ gcc_assert (enonpathdup);
+
+ /* We can't use the original probability of the joiner's out
+ edges, since the probabilities of the original branch
+ and the duplicated branches may vary after all threading is
+ complete. But apportion the duplicated joiner's off-path
+ total edge count computed earlier (total_dup_off_path_count)
+ among the duplicated off-path edges based on their original
+ ratio to the full off-path count (total_orig_off_path_count).
+ */
+ int scale = GCOV_COMPUTE_SCALE (enonpath->count,
+ total_orig_off_path_count);
+ /* Give the duplicated offpath edge a portion of the duplicated
+ total. */
+ enonpathdup->count = apply_scale (scale,
+ total_dup_off_path_count);
+ /* Now update the original offpath edge count, handling underflow
+ due to rounding errors. */
+ enonpath->count -= enonpathdup->count;
+ if (enonpath->count < 0)
+ enonpath->count = 0;
+ }
+}
+
+
+/* Check if the paths through RD all have estimated frequencies but zero
+ profile counts. This is more accurate than checking the entry block
+ for a zero profile count, since profile insanities sometimes creep in. */
+
+static bool
+estimated_freqs_path (struct redirection_data *rd)
+{
+ edge e = rd->incoming_edges->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge ein;
+ edge_iterator ei;
+ bool non_zero_freq = false;
+ FOR_EACH_EDGE (ein, ei, e->dest->preds)
+ {
+ if (ein->count)
+ return false;
+ non_zero_freq |= ein->src->frequency != 0;
+ }
+
+ for (unsigned int i = 1; i < path->length (); i++)
+ {
+ edge epath = (*path)[i]->e;
+ if (epath->src->count)
+ return false;
+ non_zero_freq |= epath->src->frequency != 0;
+ edge esucc;
+ FOR_EACH_EDGE (esucc, ei, epath->src->succs)
+ {
+ if (esucc->count)
+ return false;
+ non_zero_freq |= esucc->src->frequency != 0;
+ }
+ }
+ return non_zero_freq;
+}
+
+
+/* Invoked for routines that have guessed frequencies and no profile
+ counts to record the block and edge frequencies for paths through RD
+ in the profile count fields of those blocks and edges. This is because
+ ssa_fix_duplicate_block_edges incrementally updates the block and
+ edge counts as edges are redirected, and it is difficult to do that
+ for edge frequencies which are computed on the fly from the source
+ block frequency and probability. When a block frequency is updated
+ its outgoing edge frequencies are affected and become difficult to
+ adjust. */
+
+static void
+freqs_to_counts_path (struct redirection_data *rd)
+{
+ edge e = rd->incoming_edges->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge ein;
+ edge_iterator ei;
+ FOR_EACH_EDGE (ein, ei, e->dest->preds)
+ {
+ /* Scale up the frequency by REG_BR_PROB_BASE, to avoid rounding
+ errors applying the probability when the frequencies are very
+ small. */
+ ein->count = apply_probability (ein->src->frequency * REG_BR_PROB_BASE,
+ ein->probability);
+ }
+
+ for (unsigned int i = 1; i < path->length (); i++)
+ {
+ edge epath = (*path)[i]->e;
+ edge esucc;
+ /* Scale up the frequency by REG_BR_PROB_BASE, to avoid rounding
+ errors applying the edge probability when the frequencies are very
+ small. */
+ epath->src->count = epath->src->frequency * REG_BR_PROB_BASE;
+ FOR_EACH_EDGE (esucc, ei, epath->src->succs)
+ esucc->count = apply_probability (esucc->src->count,
+ esucc->probability);
+ }
}
-/* Wire up the outgoing edges from the duplicate block and
- update any PHIs as needed. */
+
+/* For routines that have guessed frequencies and no profile counts, where we
+ used freqs_to_counts_path to record block and edge frequencies for paths
+ through RD, we clear the counts after completing all updates for RD.
+ The updates in ssa_fix_duplicate_block_edges are based off the count fields,
+ but the block frequencies and edge probabilities were updated as well,
+ so we can simply clear the count fields. */
+
+static void
+clear_counts_path (struct redirection_data *rd)
+{
+ edge e = rd->incoming_edges->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge ein, esucc;
+ edge_iterator ei;
+ FOR_EACH_EDGE (ein, ei, e->dest->preds)
+ ein->count = 0;
+
+ /* First clear counts along original path. */
+ for (unsigned int i = 1; i < path->length (); i++)
+ {
+ edge epath = (*path)[i]->e;
+ FOR_EACH_EDGE (esucc, ei, epath->src->succs)
+ esucc->count = 0;
+ epath->src->count = 0;
+ }
+ /* Also need to clear the counts along duplicated path. */
+ for (unsigned int i = 0; i < 2; i++)
+ {
+ basic_block dup = rd->dup_blocks[i];
+ if (!dup)
+ continue;
+ FOR_EACH_EDGE (esucc, ei, dup->succs)
+ esucc->count = 0;
+ dup->count = 0;
+ }
+}
+
+/* Wire up the outgoing edges from the duplicate blocks and
+ update any PHIs as needed. Also update the profile counts
+ on the original and duplicate blocks and edges. */
void
ssa_fix_duplicate_block_edges (struct redirection_data *rd,
ssa_local_info_t *local_info)
{
- /* If we were threading through an joiner block, then we want
- to keep its control statement and redirect an outgoing edge.
- Else we want to remove the control statement & edges, then create
- a new outgoing edge. In both cases we may need to update PHIs. */
- if (THREAD_TARGET2 (rd->incoming_edges->e))
+ bool multi_incomings = (rd->incoming_edges->next != NULL);
+ edge e = rd->incoming_edges->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge elast = path->last ()->e;
+ gcov_type path_in_count = 0;
+ gcov_type path_out_count = 0;
+ int path_in_freq = 0;
+
+ /* This routine updates profile counts, frequencies, and probabilities
+ incrementally. Since it is difficult to do the incremental updates
+ using frequencies/probabilities alone, for routines without profile
+ data we first take a snapshot of the existing block and edge frequencies
+ by copying them into the empty profile count fields. These counts are
+ then used to do the incremental updates, and cleared at the end of this
+ routine. If the function is marked as having a profile, we still check
+ to see if the paths through RD are using estimated frequencies because
+ the routine had zero profile counts. */
+ bool do_freqs_to_counts = (profile_status_for_fn (cfun) != PROFILE_READ
+ || estimated_freqs_path (rd));
+ if (do_freqs_to_counts)
+ freqs_to_counts_path (rd);
+
+ /* First determine how much profile count to move from original
+ path to the duplicate path. This is tricky in the presence of
+ a joiner (see comments for compute_path_counts), where some portion
+ of the path's counts will flow off-path from the joiner. In the
+ non-joiner case the path_in_count and path_out_count should be the
+ same. */
+ bool has_joiner = compute_path_counts (rd, local_info,
+ &path_in_count, &path_out_count,
+ &path_in_freq);
+
+ int cur_path_freq = path_in_freq;
+ for (unsigned int count = 0, i = 1; i < path->length (); i++)
{
- edge victim;
- edge e2;
- edge e = rd->incoming_edges->e;
-
- /* This updates the PHIs at the destination of the duplicate
- block. */
- update_destination_phis (local_info->bb, rd->dup_block);
-
- /* Find the edge from the duplicate block to the block we're
- threading through. That's the edge we want to redirect. */
- victim = find_edge (rd->dup_block, THREAD_TARGET (e)->dest);
- e2 = redirect_edge_and_branch (victim, THREAD_TARGET2 (e)->dest);
-
- /* If we redirected the edge, then we need to copy PHI arguments
- at the target. If the edge already existed (e2 != victim case),
- then the PHIs in the target already have the correct arguments. */
- if (e2 == victim)
- copy_phi_args (e2->dest, THREAD_TARGET2 (e), e2);
+ edge epath = (*path)[i]->e;
+
+ /* If we were threading through an joiner block, then we want
+ to keep its control statement and redirect an outgoing edge.
+ Else we want to remove the control statement & edges, then create
+ a new outgoing edge. In both cases we may need to update PHIs. */
+ if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ edge victim;
+ edge e2;
+
+ gcc_assert (has_joiner);
+
+ /* This updates the PHIs at the destination of the duplicate
+ block. Pass 0 instead of i if we are threading a path which
+ has multiple incoming edges. */
+ update_destination_phis (local_info->bb, rd->dup_blocks[count],
+ path, multi_incomings ? 0 : i);
+
+ /* Find the edge from the duplicate block to the block we're
+ threading through. That's the edge we want to redirect. */
+ victim = find_edge (rd->dup_blocks[count], (*path)[i]->e->dest);
+
+ /* If there are no remaining blocks on the path to duplicate,
+ then redirect VICTIM to the final destination of the jump
+ threading path. */
+ if (!any_remaining_duplicated_blocks (path, i))
+ {
+ e2 = redirect_edge_and_branch (victim, elast->dest);
+ /* If we redirected the edge, then we need to copy PHI arguments
+ at the target. If the edge already existed (e2 != victim
+ case), then the PHIs in the target already have the correct
+ arguments. */
+ if (e2 == victim)
+ copy_phi_args (e2->dest, elast, e2,
+ path, multi_incomings ? 0 : i);
+ }
+ else
+ {
+ /* Redirect VICTIM to the next duplicated block in the path. */
+ e2 = redirect_edge_and_branch (victim, rd->dup_blocks[count + 1]);
+
+ /* We need to update the PHIs in the next duplicated block. We
+ want the new PHI args to have the same value as they had
+ in the source of the next duplicate block.
+
+ Thus, we need to know which edge we traversed into the
+ source of the duplicate. Furthermore, we may have
+ traversed many edges to reach the source of the duplicate.
+
+ Walk through the path starting at element I until we
+ hit an edge marked with EDGE_COPY_SRC_BLOCK. We want
+ the edge from the prior element. */
+ for (unsigned int j = i + 1; j < path->length (); j++)
+ {
+ if ((*path)[j]->type == EDGE_COPY_SRC_BLOCK)
+ {
+ copy_phi_arg_into_existing_phi ((*path)[j - 1]->e, e2);
+ break;
+ }
+ }
+ }
+
+ /* Update the counts and frequency of both the original block
+ and path edge, and the duplicates. The path duplicate's
+ incoming count and frequency are the totals for all edges
+ incoming to this jump threading path computed earlier.
+ And we know that the duplicated path will have path_out_count
+ flowing out of it (i.e. along the duplicated path out of the
+ duplicated joiner). */
+ update_profile (epath, e2, path_in_count, path_out_count,
+ path_in_freq);
+
+ /* Next we need to update the counts of the original and duplicated
+ edges from the joiner that go off path. */
+ update_joiner_offpath_counts (epath, e2->src, path_in_count,
+ path_out_count);
+
+ /* Finally, we need to set the probabilities on the duplicated
+ edges out of the duplicated joiner (e2->src). The probabilities
+ along the original path will all be updated below after we finish
+ processing the whole path. */
+ recompute_probabilities (e2->src);
+
+ /* Record the frequency flowing to the downstream duplicated
+ path blocks. */
+ cur_path_freq = EDGE_FREQUENCY (e2);
+ }
+ else if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK)
+ {
+ remove_ctrl_stmt_and_useless_edges (rd->dup_blocks[count], NULL);
+ create_edge_and_update_destination_phis (rd, rd->dup_blocks[count],
+ multi_incomings ? 0 : i);
+ if (count == 1)
+ single_succ_edge (rd->dup_blocks[1])->aux = NULL;
+
+ /* Update the counts and frequency of both the original block
+ and path edge, and the duplicates. Since we are now after
+ any joiner that may have existed on the path, the count
+ flowing along the duplicated threaded path is path_out_count.
+ If we didn't have a joiner, then cur_path_freq was the sum
+ of the total frequencies along all incoming edges to the
+ thread path (path_in_freq). If we had a joiner, it would have
+ been updated at the end of that handling to the edge frequency
+ along the duplicated joiner path edge. */
+ update_profile (epath, EDGE_SUCC (rd->dup_blocks[count], 0),
+ path_out_count, path_out_count,
+ cur_path_freq);
+ }
+ else
+ {
+ /* No copy case. In this case we don't have an equivalent block
+ on the duplicated thread path to update, but we do need
+ to remove the portion of the counts/freqs that were moved
+ to the duplicated path from the counts/freqs flowing through
+ this block on the original path. Since all the no-copy edges
+ are after any joiner, the removed count is the same as
+ path_out_count.
+
+ If we didn't have a joiner, then cur_path_freq was the sum
+ of the total frequencies along all incoming edges to the
+ thread path (path_in_freq). If we had a joiner, it would have
+ been updated at the end of that handling to the edge frequency
+ along the duplicated joiner path edge. */
+ update_profile (epath, NULL, path_out_count, path_out_count,
+ cur_path_freq);
+ }
+
+ /* Increment the index into the duplicated path when we processed
+ a duplicated block. */
+ if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK
+ || (*path)[i]->type == EDGE_COPY_SRC_BLOCK)
+ {
+ count++;
+ }
}
- else
+
+ /* Now walk orig blocks and update their probabilities, since the
+ counts and freqs should be updated properly by above loop. */
+ for (unsigned int i = 1; i < path->length (); i++)
{
- remove_ctrl_stmt_and_useless_edges (rd->dup_block, NULL);
- create_edge_and_update_destination_phis (rd, rd->dup_block);
+ edge epath = (*path)[i]->e;
+ recompute_probabilities (epath->src);
}
+
+ /* Done with all profile and frequency updates, clear counts if they
+ were copied. */
+ if (do_freqs_to_counts)
+ clear_counts_path (rd);
}
+
/* Hash table traversal callback routine to create duplicate blocks. */
int
{
struct redirection_data *rd = *slot;
+ /* The second duplicated block in a jump threading path is specific
+ to the path. So it gets stored in RD rather than in LOCAL_DATA.
+
+ Each time we're called, we have to look through the path and see
+ if a second block needs to be duplicated.
+
+ Note the search starts with the third edge on the path. The first
+ edge is the incoming edge, the second edge always has its source
+ duplicated. Thus we start our search with the third edge. */
+ vec<jump_thread_edge *> *path = rd->path;
+ for (unsigned int i = 2; i < path->length (); i++)
+ {
+ if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK
+ || (*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ create_block_for_threading ((*path)[i]->e->src, rd, 1,
+ &local_info->duplicate_blocks);
+ break;
+ }
+ }
+
/* Create a template block if we have not done so already. Otherwise
use the template to create a new block. */
if (local_info->template_block == NULL)
{
- create_block_for_threading (local_info->bb, rd);
- local_info->template_block = rd->dup_block;
+ create_block_for_threading ((*path)[1]->e->src, rd, 0,
+ &local_info->duplicate_blocks);
+ local_info->template_block = rd->dup_blocks[0];
/* We do not create any outgoing edges for the template. We will
take care of that in a later traversal. That way we do not
}
else
{
- create_block_for_threading (local_info->template_block, rd);
+ create_block_for_threading (local_info->template_block, rd, 0,
+ &local_info->duplicate_blocks);
/* Go ahead and wire up outgoing edges and update PHIs for the duplicate
block. */
to keep its control statement and redirect an outgoing edge.
Else we want to remove the control statement & edges, then create
a new outgoing edge. In both cases we may need to update PHIs. */
- if (rd->dup_block && rd->dup_block == local_info->template_block)
+ if (rd->dup_blocks[0] && rd->dup_blocks[0] == local_info->template_block)
{
ssa_fix_duplicate_block_edges (rd, local_info);
return 0;
for (el = rd->incoming_edges; el; el = next)
{
edge e = el->e;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
/* Go ahead and free this element from the list. Doing this now
avoids the need for another list walk when we destroy the hash
free (el);
thread_stats.num_threaded_edges++;
- /* If we are threading through a joiner block, then we have to
- find the edge we want to redirect and update some PHI nodes. */
- if (THREAD_TARGET2 (e))
- {
- edge e2;
- /* We want to redirect the incoming edge to the joiner block (E)
- to instead reach the duplicate of the joiner block. */
- e2 = redirect_edge_and_branch (e, rd->dup_block);
- flush_pending_stmts (e2);
- }
- else if (rd->dup_block)
+ if (rd->dup_blocks[0])
{
edge e2;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
- e->src->index, e->dest->index, rd->dup_block->index);
-
- rd->dup_block->count += e->count;
-
- /* Excessive jump threading may make frequencies large enough so
- the computation overflows. */
- if (rd->dup_block->frequency < BB_FREQ_MAX * 2)
- rd->dup_block->frequency += EDGE_FREQUENCY (e);
- EDGE_SUCC (rd->dup_block, 0)->count += e->count;
- /* Redirect the incoming edge to the appropriate duplicate
- block. */
- e2 = redirect_edge_and_branch (e, rd->dup_block);
+ e->src->index, e->dest->index, rd->dup_blocks[0]->index);
+
+ /* If we redirect a loop latch edge cancel its loop. */
+ if (e->src == e->src->loop_father->latch)
+ mark_loop_for_removal (e->src->loop_father);
+
+ /* Redirect the incoming edge (possibly to the joiner block) to the
+ appropriate duplicate block. */
+ e2 = redirect_edge_and_branch (e, rd->dup_blocks[0]);
gcc_assert (e == e2);
flush_pending_stmts (e2);
}
/* Go ahead and clear E->aux. It's not needed anymore and failure
- to clear it will cause all kinds of unpleasant problems later. */
- free (e->aux);
+ to clear it will cause all kinds of unpleasant problems later. */
+ delete_jump_thread_path (path);
e->aux = NULL;
}
/* Advance to the first executable statement. */
gsi = gsi_start_bb (bb);
while (!gsi_end_p (gsi)
- && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
+ && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
|| is_gimple_debug (gsi_stmt (gsi))
- || gimple_nop_p (gsi_stmt (gsi))))
+ || gimple_nop_p (gsi_stmt (gsi))))
gsi_next (&gsi);
/* Check if this is an empty block. */
/* Test that we've reached the terminating control statement. */
return gsi_stmt (gsi)
- && (gimple_code (gsi_stmt (gsi)) == GIMPLE_COND
- || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
- || gimple_code (gsi_stmt (gsi)) == GIMPLE_SWITCH);
+ && (gimple_code (gsi_stmt (gsi)) == GIMPLE_COND
+ || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
+ || gimple_code (gsi_stmt (gsi)) == GIMPLE_SWITCH);
}
/* BB is a block which ends with a COND_EXPR or SWITCH_EXPR and when BB
the appropriate duplicate of BB.
If NOLOOP_ONLY is true, we only perform the threading as long as it
- does not affect the structure of the loops in a nontrivial way. */
+ does not affect the structure of the loops in a nontrivial way.
+
+ If JOINERS is true, then thread through joiner blocks as well. */
static bool
-thread_block (basic_block bb, bool noloop_only)
+thread_block_1 (basic_block bb, bool noloop_only, bool joiners)
{
/* E is an incoming edge into BB that we may or may not want to
redirect to a duplicate of BB. */
edge e, e2;
edge_iterator ei;
ssa_local_info_t local_info;
- struct loop *loop = bb->loop_father;
+
+ local_info.duplicate_blocks = BITMAP_ALLOC (NULL);
/* To avoid scanning a linear array for the element we need we instead
use a hash table. For normal code there should be no noticeable
difference. However, if we have a block with a large number of
incoming and outgoing edges such linear searches can get expensive. */
- redirection_data.create (EDGE_COUNT (bb->succs));
-
- /* If we thread the latch of the loop to its exit, the loop ceases to
- exist. Make sure we do not restrict ourselves in order to preserve
- this loop. */
- if (loop->header == bb)
- {
- e = loop_latch_edge (loop);
-
- if (e->aux)
- e2 = THREAD_TARGET (e);
- else
- e2 = NULL;
-
- if (e2 && loop_exit_edge_p (loop, e2))
- {
- loop->header = NULL;
- loop->latch = NULL;
- loops_state_set (LOOPS_NEED_FIXUP);
- }
- }
+ redirection_data
+ = new hash_table<struct redirection_data> (EDGE_COUNT (bb->succs));
/* Record each unique threaded destination into a hash table for
efficient lookups. */
if (e->aux == NULL)
continue;
- if (THREAD_TARGET2 (e))
- e2 = THREAD_TARGET2 (e);
- else
- e2 = THREAD_TARGET (e);
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+
+ if (((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK && !joiners)
+ || ((*path)[1]->type == EDGE_COPY_SRC_BLOCK && joiners))
+ continue;
- if (!e2
+ e2 = path->last ()->e;
+ if (!e2 || noloop_only)
+ {
/* If NOLOOP_ONLY is true, we only allow threading through the
header of a loop to exit edges. */
- || (noloop_only
- && bb == bb->loop_father->header
- && (!loop_exit_edge_p (bb->loop_father, e2)
- || THREAD_TARGET2 (e))))
- continue;
- if (e->dest == e2->src)
- update_bb_profile_for_threading (e->dest, EDGE_FREQUENCY (e),
- e->count, THREAD_TARGET (e));
+ /* One case occurs when there was loop header buried in a jump
+ threading path that crosses loop boundaries. We do not try
+ and thread this elsewhere, so just cancel the jump threading
+ request by clearing the AUX field now. */
+ if ((bb->loop_father != e2->src->loop_father
+ && !loop_exit_edge_p (e2->src->loop_father, e2))
+ || (e2->src->loop_father != e2->dest->loop_father
+ && !loop_exit_edge_p (e2->src->loop_father, e2)))
+ {
+ /* Since this case is not handled by our special code
+ to thread through a loop header, we must explicitly
+ cancel the threading request here. */
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ continue;
+ }
+
+ /* Another case occurs when trying to thread through our
+ own loop header, possibly from inside the loop. We will
+ thread these later. */
+ unsigned int i;
+ for (i = 1; i < path->length (); i++)
+ {
+ if ((*path)[i]->e->src == bb->loop_father->header
+ && (!loop_exit_edge_p (bb->loop_father, e2)
+ || (*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK))
+ break;
+ }
+
+ if (i != path->length ())
+ continue;
+ }
/* Insert the outgoing edge into the hash table if it is not
already in the hash table. */
local_info.template_block = NULL;
local_info.bb = bb;
local_info.jumps_threaded = false;
- redirection_data.traverse <ssa_local_info_t *, ssa_create_duplicates>
+ redirection_data->traverse <ssa_local_info_t *, ssa_create_duplicates>
(&local_info);
/* The template does not have an outgoing edge. Create that outgoing
We do this after creating all the duplicates to avoid creating
unnecessary edges. */
- redirection_data.traverse <ssa_local_info_t *, ssa_fixup_template_block>
+ redirection_data->traverse <ssa_local_info_t *, ssa_fixup_template_block>
(&local_info);
/* The hash table traversals above created the duplicate blocks (and the
statements within the duplicate blocks). This loop creates PHI nodes for
the duplicated blocks and redirects the incoming edges into BB to reach
the duplicates of BB. */
- redirection_data.traverse <ssa_local_info_t *, ssa_redirect_edges>
+ redirection_data->traverse <ssa_local_info_t *, ssa_redirect_edges>
(&local_info);
/* Done with this block. Clear REDIRECTION_DATA. */
- redirection_data.dispose ();
+ delete redirection_data;
+ redirection_data = NULL;
if (noloop_only
&& bb == bb->loop_father->header)
set_loop_copy (bb->loop_father, NULL);
+ BITMAP_FREE (local_info.duplicate_blocks);
+ local_info.duplicate_blocks = NULL;
+
/* Indicate to our caller whether or not any jumps were threaded. */
return local_info.jumps_threaded;
}
+/* Wrapper for thread_block_1 so that we can first handle jump
+ thread paths which do not involve copying joiner blocks, then
+ handle jump thread paths which have joiner blocks.
+
+ By doing things this way we can be as aggressive as possible and
+ not worry that copying a joiner block will create a jump threading
+ opportunity. */
+
+static bool
+thread_block (basic_block bb, bool noloop_only)
+{
+ bool retval;
+ retval = thread_block_1 (bb, noloop_only, false);
+ retval |= thread_block_1 (bb, noloop_only, true);
+ return retval;
+}
+
+
/* Threads edge E through E->dest to the edge THREAD_TARGET (E). Returns the
copy of E->dest created during threading, or E->dest if it was not necessary
to copy it (E is its single predecessor). */
thread_single_edge (edge e)
{
basic_block bb = e->dest;
- edge eto = THREAD_TARGET (e);
struct redirection_data rd;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ edge eto = (*path)[1]->e;
- free (e->aux);
+ for (unsigned int i = 0; i < path->length (); i++)
+ delete (*path)[i];
+ delete path;
e->aux = NULL;
thread_stats.num_threaded_edges++;
if (e->dest == eto->src)
update_bb_profile_for_threading (bb, EDGE_FREQUENCY (e), e->count, eto);
- rd.outgoing_edge = eto;
+ vec<jump_thread_edge *> *npath = new vec<jump_thread_edge *> ();
+ jump_thread_edge *x = new jump_thread_edge (e, EDGE_START_JUMP_THREAD);
+ npath->safe_push (x);
+
+ x = new jump_thread_edge (eto, EDGE_COPY_SRC_BLOCK);
+ npath->safe_push (x);
+ rd.path = npath;
- create_block_for_threading (bb, &rd);
- remove_ctrl_stmt_and_useless_edges (rd.dup_block, NULL);
- create_edge_and_update_destination_phis (&rd, rd.dup_block);
+ create_block_for_threading (bb, &rd, 0, NULL);
+ remove_ctrl_stmt_and_useless_edges (rd.dup_blocks[0], NULL);
+ create_edge_and_update_destination_phis (&rd, rd.dup_blocks[0], 0);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
- e->src->index, e->dest->index, rd.dup_block->index);
+ e->src->index, e->dest->index, rd.dup_blocks[0]->index);
- rd.dup_block->count = e->count;
- rd.dup_block->frequency = EDGE_FREQUENCY (e);
- single_succ_edge (rd.dup_block)->count = e->count;
- redirect_edge_and_branch (e, rd.dup_block);
+ rd.dup_blocks[0]->count = e->count;
+ rd.dup_blocks[0]->frequency = EDGE_FREQUENCY (e);
+ single_succ_edge (rd.dup_blocks[0])->count = e->count;
+ redirect_edge_and_branch (e, rd.dup_blocks[0]);
flush_pending_stmts (e);
- return rd.dup_block;
+ return rd.dup_blocks[0];
}
/* Callback for dfs_enumerate_from. Returns true if BB is different
if (single_succ_p (header))
goto fail;
+ /* If we threaded the latch using a joiner block, we cancel the
+ threading opportunity out of an abundance of caution. However,
+ still allow threading from outside to inside the loop. */
if (latch->aux)
{
- if (THREAD_TARGET2 (latch))
- goto fail;
- tgt_edge = THREAD_TARGET (latch);
+ vec<jump_thread_edge *> *path = THREAD_PATH (latch);
+ if ((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ delete_jump_thread_path (path);
+ latch->aux = NULL;
+ }
+ }
+
+ if (latch->aux)
+ {
+ vec<jump_thread_edge *> *path = THREAD_PATH (latch);
+ tgt_edge = (*path)[1]->e;
tgt_bb = tgt_edge->dest;
}
else if (!may_peel_loop_headers
goto fail;
}
- if (THREAD_TARGET2 (e))
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+
+ if ((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK)
goto fail;
- tgt_edge = THREAD_TARGET (e);
+ tgt_edge = (*path)[1]->e;
atgt_bb = tgt_edge->dest;
if (!tgt_bb)
tgt_bb = atgt_bb;
{
/* If the loop ceased to exist, mark it as such, and thread through its
original header. */
- loop->header = NULL;
- loop->latch = NULL;
- loops_state_set (LOOPS_NEED_FIXUP);
+ mark_loop_for_removal (loop);
return thread_block (header, false);
}
unsigned nblocks, i;
/* First handle the case latch edge is redirected. We are copying
- the loop header but not creating a multiple entry loop. Make the
+ the loop header but not creating a multiple entry loop. Make the
cfg manipulation code aware of that fact. */
set_loop_copy (loop, loop);
loop->latch = thread_single_edge (latch);
if (e->aux == NULL)
continue;
- if (THREAD_TARGET2 (e))
- e2 = THREAD_TARGET2 (e);
- else
- e2 = THREAD_TARGET (e);
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ e2 = path->last ()->e;
if (e->src->loop_father != e2->dest->loop_father
&& e2->dest != loop->header)
{
- free (e->aux);
+ delete_jump_thread_path (path);
e->aux = NULL;
}
}
/* We failed to thread anything. Cancel the requests. */
FOR_EACH_EDGE (e, ei, header->preds)
{
- free (e->aux);
- e->aux = NULL;
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+
+ if (path)
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ }
}
return false;
}
+/* E1 and E2 are edges into the same basic block. Return TRUE if the
+ PHI arguments associated with those edges are equal or there are no
+ PHI arguments, otherwise return FALSE. */
+
+static bool
+phi_args_equal_on_edges (edge e1, edge e2)
+{
+ gphi_iterator gsi;
+ int indx1 = e1->dest_idx;
+ int indx2 = e2->dest_idx;
+
+ for (gsi = gsi_start_phis (e1->dest); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gphi *phi = gsi.phi ();
+
+ if (!operand_equal_p (gimple_phi_arg_def (phi, indx1),
+ gimple_phi_arg_def (phi, indx2), 0))
+ return false;
+ }
+ return true;
+}
+
/* Walk through the registered jump threads and convert them into a
form convenient for this pass.
edge e;
edge_iterator ei;
- for (i = 0; i < threaded_edges.length (); i += 3)
+ /* It is possible to have jump threads in which one is a subpath
+ of the other. ie, (A, B), (B, C), (C, D) where B is a joiner
+ block and (B, C), (C, D) where no joiner block exists.
+
+ When this occurs ignore the jump thread request with the joiner
+ block. It's totally subsumed by the simpler jump thread request.
+
+ This results in less block copying, simpler CFGs. More importantly,
+ when we duplicate the joiner block, B, in this case we will create
+ a new threading opportunity that we wouldn't be able to optimize
+ until the next jump threading iteration.
+
+ So first convert the jump thread requests which do not require a
+ joiner block. */
+ for (i = 0; i < paths.length (); i++)
{
- edge e = threaded_edges[i];
- edge *x = XNEWVEC (edge, 2);
+ vec<jump_thread_edge *> *path = paths[i];
- e->aux = x;
- THREAD_TARGET (e) = threaded_edges[i + 1];
- THREAD_TARGET2 (e) = threaded_edges[i + 2];
- bitmap_set_bit (tmp, e->dest->index);
+ if ((*path)[1]->type != EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ edge e = (*path)[0]->e;
+ e->aux = (void *)path;
+ bitmap_set_bit (tmp, e->dest->index);
+ }
+ }
+
+ /* Now iterate again, converting cases where we want to thread
+ through a joiner block, but only if no other edge on the path
+ already has a jump thread attached to it. We do this in two passes,
+ to avoid situations where the order in the paths vec can hide overlapping
+ threads (the path is recorded on the incoming edge, so we would miss
+ cases where the second path starts at a downstream edge on the same
+ path). First record all joiner paths, deleting any in the unexpected
+ case where there is already a path for that incoming edge. */
+ for (i = 0; i < paths.length (); i++)
+ {
+ vec<jump_thread_edge *> *path = paths[i];
+
+ if ((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK)
+ {
+ /* Attach the path to the starting edge if none is yet recorded. */
+ if ((*path)[0]->e->aux == NULL)
+ (*path)[0]->e->aux = path;
+ else if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_jump_thread_path (dump_file, *path, false);
+ }
+ }
+ /* Second, look for paths that have any other jump thread attached to
+ them, and either finish converting them or cancel them. */
+ for (i = 0; i < paths.length (); i++)
+ {
+ vec<jump_thread_edge *> *path = paths[i];
+ edge e = (*path)[0]->e;
+
+ if ((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK && e->aux == path)
+ {
+ unsigned int j;
+ for (j = 1; j < path->length (); j++)
+ if ((*path)[j]->e->aux != NULL)
+ break;
+
+ /* If we iterated through the entire path without exiting the loop,
+ then we are good to go, record it. */
+ if (j == path->length ())
+ bitmap_set_bit (tmp, e->dest->index);
+ else
+ {
+ e->aux = NULL;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_jump_thread_path (dump_file, *path, false);
+ }
+ }
}
/* If optimizing for size, only thread through block if we don't have
{
EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
{
- bb = BASIC_BLOCK (i);
+ bb = BASIC_BLOCK_FOR_FN (cfun, i);
if (EDGE_COUNT (bb->preds) > 1
&& !redirection_block_p (bb))
{
FOR_EACH_EDGE (e, ei, bb->preds)
{
- free (e->aux);
- e->aux = NULL;
+ if (e->aux)
+ {
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ }
}
}
else
else
bitmap_copy (threaded_blocks, tmp);
- BITMAP_FREE(tmp);
+ /* Look for jump threading paths which cross multiple loop headers.
+
+ The code to thread through loop headers will change the CFG in ways
+ that break assumptions made by the loop optimization code.
+
+ We don't want to blindly cancel the requests. We can instead do better
+ by trimming off the end of the jump thread path. */
+ EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
+ {
+ basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ {
+ if (e->aux)
+ {
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+
+ for (unsigned int i = 0, crossed_headers = 0;
+ i < path->length ();
+ i++)
+ {
+ basic_block dest = (*path)[i]->e->dest;
+ crossed_headers += (dest == dest->loop_father->header);
+ if (crossed_headers > 1)
+ {
+ /* Trim from entry I onwards. */
+ for (unsigned int j = i; j < path->length (); j++)
+ delete (*path)[j];
+ path->truncate (i);
+
+ /* Now that we've truncated the path, make sure
+ what's left is still valid. We need at least
+ two edges on the path and the last edge can not
+ be a joiner. This should never happen, but let's
+ be safe. */
+ if (path->length () < 2
+ || (path->last ()->type
+ == EDGE_COPY_SRC_JOINER_BLOCK))
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ /* If we have a joiner block (J) which has two successors S1 and S2 and
+ we are threading though S1 and the final destination of the thread
+ is S2, then we must verify that any PHI nodes in S2 have the same
+ PHI arguments for the edge J->S2 and J->S1->...->S2.
+
+ We used to detect this prior to registering the jump thread, but
+ that prohibits propagation of edge equivalences into non-dominated
+ PHI nodes as the equivalency test might occur before propagation.
+
+ This must also occur after we truncate any jump threading paths
+ as this scenario may only show up after truncation.
+
+ This works for now, but will need improvement as part of the FSA
+ optimization.
+
+ Note since we've moved the thread request data to the edges,
+ we have to iterate on those rather than the threaded_edges vector. */
+ EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
+ {
+ bb = BASIC_BLOCK_FOR_FN (cfun, i);
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ {
+ if (e->aux)
+ {
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+ bool have_joiner = ((*path)[1]->type == EDGE_COPY_SRC_JOINER_BLOCK);
+
+ if (have_joiner)
+ {
+ basic_block joiner = e->dest;
+ edge final_edge = path->last ()->e;
+ basic_block final_dest = final_edge->dest;
+ edge e2 = find_edge (joiner, final_dest);
+
+ if (e2 && !phi_args_equal_on_edges (e2, final_edge))
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ }
+ }
+ }
+ }
+ }
+
+ BITMAP_FREE (tmp);
}
+/* Return TRUE if BB ends with a switch statement or a computed goto.
+ Otherwise return false. */
+static bool
+bb_ends_with_multiway_branch (basic_block bb ATTRIBUTE_UNUSED)
+{
+ gimple stmt = last_stmt (bb);
+ if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
+ return true;
+ if (stmt && gimple_code (stmt) == GIMPLE_GOTO
+ && TREE_CODE (gimple_goto_dest (stmt)) == SSA_NAME)
+ return true;
+ return false;
+}
+
/* Walk through all blocks and thread incoming edges to the appropriate
outgoing edge for each edge pair recorded in THREADED_EDGES.
bitmap_iterator bi;
bitmap threaded_blocks;
struct loop *loop;
- loop_iterator li;
- /* We must know about loops in order to preserve them. */
- gcc_assert (current_loops != NULL);
-
- if (!threaded_edges.exists ())
+ if (!paths.exists ())
return false;
threaded_blocks = BITMAP_ALLOC (NULL);
loop structure. */
EXECUTE_IF_SET_IN_BITMAP (threaded_blocks, 0, i, bi)
{
- basic_block bb = BASIC_BLOCK (i);
+ basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
if (EDGE_COUNT (bb->preds) > 0)
retval |= thread_block (bb, true);
/* Then perform the threading through loop headers. We start with the
innermost loop, so that the changes in cfg we perform won't affect
further threading. */
- FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST)
+ FOR_EACH_LOOP (loop, LI_FROM_INNERMOST)
{
if (!loop->header
|| !bitmap_bit_p (threaded_blocks, loop->header->index))
retval |= thread_through_loop_header (loop, may_peel_loop_headers);
}
+ /* Any jump threading paths that are still attached to edges at this
+ point must be one of two cases.
+
+ First, we could have a jump threading path which went from outside
+ a loop to inside a loop that was ignored because a prior jump thread
+ across a backedge was realized (which indirectly causes the loop
+ above to ignore the latter thread). We can detect these because the
+ loop structures will be different and we do not currently try to
+ optimize this case.
+
+ Second, we could be threading across a backedge to a point within the
+ same loop. This occurrs for the FSA/FSM optimization and we would
+ like to optimize it. However, we have to be very careful as this
+ may completely scramble the loop structures, with the result being
+ irreducible loops causing us to throw away our loop structure.
+
+ As a compromise for the latter case, if the thread path ends in
+ a block where the last statement is a multiway branch, then go
+ ahead and thread it, else ignore it. */
+ basic_block bb;
+ edge e;
+ FOR_EACH_BB_FN (bb, cfun)
+ {
+ /* If we do end up threading here, we can remove elements from
+ BB->preds. Thus we can not use the FOR_EACH_EDGE iterator. */
+ for (edge_iterator ei = ei_start (bb->preds);
+ (e = ei_safe_edge (ei));)
+ if (e->aux)
+ {
+ vec<jump_thread_edge *> *path = THREAD_PATH (e);
+
+ /* Case 1, threading from outside to inside the loop
+ after we'd already threaded through the header. */
+ if ((*path)[0]->e->dest->loop_father
+ != path->last ()->e->src->loop_father)
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ ei_next (&ei);
+ }
+ else if (bb_ends_with_multiway_branch (path->last ()->e->src))
+ {
+ /* The code to thread through loop headers may have
+ split a block with jump threads attached to it.
+
+ We can identify this with a disjoint jump threading
+ path. If found, just remove it. */
+ for (unsigned int i = 0; i < path->length () - 1; i++)
+ if ((*path)[i]->e->dest != (*path)[i + 1]->e->src)
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ ei_next (&ei);
+ break;
+ }
+
+ /* Our path is still valid, thread it. */
+ if (e->aux)
+ {
+ struct loop *loop = (*path)[0]->e->dest->loop_father;
+
+ if (thread_block ((*path)[0]->e->dest, false))
+ {
+ /* This jump thread likely totally scrambled this loop.
+ So arrange for it to be fixed up. */
+ loop->header = NULL;
+ loop->latch = NULL;
+ e->aux = NULL;
+ }
+ else
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ ei_next (&ei);
+ }
+ }
+ }
+ else
+ {
+ delete_jump_thread_path (path);
+ e->aux = NULL;
+ ei_next (&ei);
+ }
+ }
+ else
+ ei_next (&ei);
+ }
+
statistics_counter_event (cfun, "Jumps threaded",
thread_stats.num_threaded_edges);
BITMAP_FREE (threaded_blocks);
threaded_blocks = NULL;
- threaded_edges.release ();
+ paths.release ();
if (retval)
loops_state_set (LOOPS_NEED_FIXUP);
return retval;
}
+/* Delete the jump threading path PATH. We have to explcitly delete
+ each entry in the vector, then the container. */
+
+void
+delete_jump_thread_path (vec<jump_thread_edge *> *path)
+{
+ for (unsigned int i = 0; i < path->length (); i++)
+ delete (*path)[i];
+ path->release();
+}
+
/* Register a jump threading opportunity. We queue up all the jump
threading opportunities discovered by a pass and update the CFG
and SSA form all at once.
after fixing the SSA graph. */
void
-register_jump_thread (vec<edge> path)
+register_jump_thread (vec<jump_thread_edge *> *path)
{
- /* Convert PATH into 3 edge representation we've been using. This
- is temporary until we convert this file to use a path representation
- throughout. */
- edge e = path[0];
- edge e2 = path[1];
-
- if (path.length () <= 2)
- e3 = NULL;
- else
- e3 = path[path.length () - 1];
+ if (!dbg_cnt (registered_jump_thread))
+ {
+ delete_jump_thread_path (path);
+ return;
+ }
+
+ /* First make sure there are no NULL outgoing edges on the jump threading
+ path. That can happen for jumping to a constant address. */
+ for (unsigned int i = 0; i < path->length (); i++)
+ if ((*path)[i]->e == NULL)
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file,
+ "Found NULL edge in jump threading path. Cancelling jump thread:\n");
+ dump_jump_thread_path (dump_file, *path, false);
+ }
- /* This can occur if we're jumping to a constant address or
- or something similar. Just get out now. */
- if (e2 == NULL)
- return;
+ delete_jump_thread_path (path);
+ return;
+ }
- if (!threaded_edges.exists ())
- threaded_edges.create (15);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_jump_thread_path (dump_file, *path, true);
- if (dump_file && (dump_flags & TDF_DETAILS)
- && e->dest != e2->src)
- fprintf (dump_file,
- " Registering jump thread around one or more intermediate blocks\n");
+ if (!paths.exists ())
+ paths.create (5);
- threaded_edges.safe_push (e);
- threaded_edges.safe_push (e2);
- threaded_edges.safe_push (e3);
+ paths.safe_push (path);
}
projects / gcc.git / blobdiff