+/* Hashing and equality routines for our hash table. */
+static hashval_t
+redirection_data_hash (const void *p)
+{
+ edge e = ((const struct redirection_data *)p)->outgoing_edge;
+ return e->dest->index;
+}
+
+static int
+redirection_data_eq (const void *p1, const void *p2)
+{
+ edge e1 = ((const struct redirection_data *)p1)->outgoing_edge;
+ edge e2 = ((const struct redirection_data *)p2)->outgoing_edge;
+
+ return e1 == e2;
+}
+
+/* Given an outgoing edge E lookup and return its entry in our hash table.
+
+ If INSERT is true, then we insert the entry into the hash table if
+ it is not already present. INCOMING_EDGE is added to the list of incoming
+ edges associated with E in the hash table. */
+
+static struct redirection_data *
+lookup_redirection_data (edge e, edge incoming_edge, enum insert_option insert)
+{
+ void **slot;
+ struct redirection_data *elt;
+
+ /* Build a hash table element so we can see if E is already
+ in the table. */
+ elt = XNEW (struct redirection_data);
+ elt->outgoing_edge = e;
+ elt->dup_block = NULL;
+ elt->do_not_duplicate = false;
+ elt->incoming_edges = NULL;
+
+ slot = htab_find_slot (redirection_data, elt, insert);
+
+ /* This will only happen if INSERT is false and the entry is not
+ in the hash table. */
+ if (slot == NULL)
+ {
+ free (elt);
+ return NULL;
+ }
+
+ /* This will only happen if E was not in the hash table and
+ INSERT is true. */
+ if (*slot == NULL)
+ {
+ *slot = (void *)elt;
+ elt->incoming_edges = XNEW (struct el);
+ elt->incoming_edges->e = incoming_edge;
+ elt->incoming_edges->next = NULL;
+ return elt;
+ }
+ /* E was in the hash table. */
+ else
+ {
+ /* Free ELT as we do not need it anymore, we will extract the
+ relevant entry from the hash table itself. */
+ free (elt);
+
+ /* Get the entry stored in the hash table. */
+ elt = (struct redirection_data *) *slot;
+
+ /* If insertion was requested, then we need to add INCOMING_EDGE
+ to the list of incoming edges associated with E. */
+ if (insert)
+ {
+ struct el *el = XNEW (struct el);
+ el->next = elt->incoming_edges;
+ el->e = incoming_edge;
+ elt->incoming_edges = el;
+ }
+
+ return elt;
+ }
+}
+
+/* Given a duplicate block and its single destination (both stored
+ in RD). Create an edge between the duplicate and its single
+ destination.
+
+ Add an additional argument to any PHI nodes at the single
+ destination. */
+
+static void
+create_edge_and_update_destination_phis (struct redirection_data *rd)
+{
+ edge e = make_edge (rd->dup_block, rd->outgoing_edge->dest, EDGE_FALLTHRU);
+ gimple_stmt_iterator gsi;
+
+ rescan_loop_exit (e, true, false);
+ e->probability = REG_BR_PROB_BASE;
+ e->count = rd->dup_block->count;
+ e->aux = rd->outgoing_edge->aux;
+
+ /* 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. */
+ for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple phi = gsi_stmt (gsi);
+ source_location locus;
+ int indx = rd->outgoing_edge->dest_idx;
+
+ locus = gimple_phi_arg_location (phi, indx);
+ add_phi_arg (phi, gimple_phi_arg_def (phi, indx), e, locus);
+ }
+}
+
+/* Hash table traversal callback routine to create duplicate blocks. */
+
+static int
+create_duplicates (void **slot, void *data)
+{
+ struct redirection_data *rd = (struct redirection_data *) *slot;
+ struct local_info *local_info = (struct local_info *)data;
+
+ /* If this entry should not have a duplicate created, then there's
+ nothing to do. */
+ if (rd->do_not_duplicate)
+ return 1;
+
+ /* 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;
+
+ /* 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
+ create edges that are going to just be deleted. */
+ }
+ else
+ {
+ create_block_for_threading (local_info->template_block, rd);
+
+ /* Go ahead and wire up outgoing edges and update PHIs for the duplicate
+ block. */
+ create_edge_and_update_destination_phis (rd);
+ }
+
+ /* Keep walking the hash table. */
+ return 1;
+}
+
+/* We did not create any outgoing edges for the template block during
+ block creation. This hash table traversal callback creates the
+ outgoing edge for the template block. */
+
+static int
+fixup_template_block (void **slot, void *data)
+{
+ struct redirection_data *rd = (struct redirection_data *) *slot;
+ struct local_info *local_info = (struct local_info *)data;
+
+ /* If this is the template block, then create its outgoing edges
+ and halt the hash table traversal. */
+ if (rd->dup_block && rd->dup_block == local_info->template_block)
+ {
+ create_edge_and_update_destination_phis (rd);
+ return 0;
+ }
+
+ return 1;
+}
+
+/* Hash table traversal callback to redirect each incoming edge
+ associated with this hash table element to its new destination. */
+
+static int
+redirect_edges (void **slot, void *data)
+{
+ struct redirection_data *rd = (struct redirection_data *) *slot;
+ struct local_info *local_info = (struct local_info *)data;
+ struct el *next, *el;
+
+ /* Walk over all the incoming edges associated associated with this
+ hash table entry. */
+ for (el = rd->incoming_edges; el; el = next)
+ {
+ edge e = el->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
+ table. */
+ next = el->next;
+ free (el);
+
+ /* Go ahead and clear E->aux. It's not needed anymore and failure
+ to clear it will cause all kinds of unpleasant problems later. */
+ e->aux = NULL;
+
+ thread_stats.num_threaded_edges++;
+
+ if (rd->dup_block)
+ {
+ 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;
+ 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);
+ gcc_assert (e == e2);
+ flush_pending_stmts (e2);
+ }
+ else
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
+ e->src->index, e->dest->index, local_info->bb->index);
+
+ /* We are using BB as the duplicate. Remove the unnecessary
+ outgoing edges and statements from BB. */
+ remove_ctrl_stmt_and_useless_edges (local_info->bb,
+ rd->outgoing_edge->dest);
+
+ /* Fixup the flags on the single remaining edge. */
+ single_succ_edge (local_info->bb)->flags
+ &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE | EDGE_ABNORMAL);
+ single_succ_edge (local_info->bb)->flags |= EDGE_FALLTHRU;
+
+ /* And adjust count and frequency on BB. */
+ local_info->bb->count = e->count;
+ local_info->bb->frequency = EDGE_FREQUENCY (e);
+ }
+ }
+
+ /* Indicate that we actually threaded one or more jumps. */
+ if (rd->incoming_edges)
+ local_info->jumps_threaded = true;
+
+ return 1;
+}
+
+/* Return true if this block has no executable statements other than
+ a simple ctrl flow instruction. When the number of outgoing edges
+ is one, this is equivalent to a "forwarder" block. */
+
+static bool
+redirection_block_p (basic_block bb)
+{
+ gimple_stmt_iterator gsi;
+
+ /* Advance to the first executable statement. */
+ gsi = gsi_start_bb (bb);
+ while (!gsi_end_p (gsi)
+ && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
+ || is_gimple_debug (gsi_stmt (gsi))
+ || gimple_nop_p (gsi_stmt (gsi))))
+ gsi_next (&gsi);
+
+ /* Check if this is an empty block. */
+ if (gsi_end_p (gsi))
+ return true;
+
+ /* 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);
+}
+