+ 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);
+ }