diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5618d20ccfc..f02ba5cc1c3 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,8 @@ +2015-05-26 Jeff Law + + * tree-ssa-threadupdate.c: Replace 8 space sequences with tabs. + No functional changes. + 2015-05-26 Jan Hubicka * ipa-polymorphic-call.c diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c index 4bccad0156a..ce1dcdb96a7 100644 --- a/gcc/tree-ssa-threadupdate.c +++ b/gcc/tree-ssa-threadupdate.c @@ -605,25 +605,25 @@ any_remaining_duplicated_blocks (vec *path, 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 + 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) + 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 @@ -639,22 +639,22 @@ any_remaining_duplicated_blocks (vec *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 + 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 @@ -684,10 +684,10 @@ any_remaining_duplicated_blocks (vec *path, 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) + 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 *path = THREAD_PATH (e); @@ -699,13 +699,13 @@ compute_path_counts (struct redirection_data *rd, /* 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. + 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 @@ -727,23 +727,23 @@ compute_path_counts (struct redirection_data *rd, vec *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); - } + && 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; - } + { + /* 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. */ @@ -786,31 +786,31 @@ compute_path_counts (struct redirection_data *rd, 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); - } + { + 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. */ + 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; - } + /* 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; + path_out_count = cur_count; if (epath->count < min_path_count) - min_path_count = epath->count; + min_path_count = epath->count; } /* We computed path_out_count above assuming that this path targeted @@ -850,7 +850,7 @@ compute_path_counts (struct redirection_data *rd, 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) + gcov_type path_out_count, int path_in_freq) { /* First update the duplicated block's count / frequency. */ @@ -899,22 +899,22 @@ recompute_probabilities (basic_block bb) FOR_EACH_EDGE (esucc, ei, bb->succs) { if (!bb->count) - continue; + continue; /* Prevent overflow computation due to insane profiles. */ if (esucc->count < bb->count) - esucc->probability = GCOV_COMPUTE_SCALE (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; + /* 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; } } @@ -927,8 +927,8 @@ recompute_probabilities (basic_block bb) static void update_joiner_offpath_counts (edge epath, basic_block dup_bb, - gcov_type path_in_count, - gcov_type path_out_count) + 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 @@ -943,7 +943,7 @@ update_joiner_offpath_counts (edge epath, basic_block dup_bb, FOR_EACH_EDGE (enonpath, ei, epath->src->succs) { if (enonpath == epath) - continue; + continue; total_orig_off_path_count += enonpath->count; } @@ -959,31 +959,31 @@ update_joiner_offpath_counts (edge epath, basic_block dup_bb, { /* Look for edges going off of the threading path. */ if (enonpath == epath) - continue; + 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). - */ + 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); + total_orig_off_path_count); /* Give the duplicated offpath edge a portion of the duplicated - total. */ + total. */ enonpathdup->count = apply_scale (scale, - total_dup_off_path_count); + total_dup_off_path_count); /* Now update the original offpath edge count, handling underflow - due to rounding errors. */ + due to rounding errors. */ enonpath->count -= enonpathdup->count; if (enonpath->count < 0) - enonpath->count = 0; + enonpath->count = 0; } } @@ -1003,7 +1003,7 @@ estimated_freqs_path (struct redirection_data *rd) FOR_EACH_EDGE (ein, ei, e->dest->preds) { if (ein->count) - return false; + return false; non_zero_freq |= ein->src->frequency != 0; } @@ -1011,15 +1011,15 @@ estimated_freqs_path (struct redirection_data *rd) { edge epath = (*path)[i]->e; if (epath->src->count) - return false; + 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; - } + { + if (esucc->count) + return false; + non_zero_freq |= esucc->src->frequency != 0; + } } return non_zero_freq; } @@ -1045,10 +1045,10 @@ freqs_to_counts_path (struct redirection_data *rd) 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. */ + errors applying the probability when the frequencies are very + small. */ ein->count = apply_probability (ein->src->frequency * REG_BR_PROB_BASE, - ein->probability); + ein->probability); } for (unsigned int i = 1; i < path->length (); i++) @@ -1056,12 +1056,12 @@ freqs_to_counts_path (struct redirection_data *rd) 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. */ + 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); + esucc->count = apply_probability (esucc->src->count, + esucc->probability); } } @@ -1088,7 +1088,7 @@ clear_counts_path (struct redirection_data *rd) { edge epath = (*path)[i]->e; FOR_EACH_EDGE (esucc, ei, epath->src->succs) - esucc->count = 0; + esucc->count = 0; epath->src->count = 0; } /* Also need to clear the counts along duplicated path. */ @@ -1096,9 +1096,9 @@ clear_counts_path (struct redirection_data *rd) { basic_block dup = rd->dup_blocks[i]; if (!dup) - continue; + continue; FOR_EACH_EDGE (esucc, ei, dup->succs) - esucc->count = 0; + esucc->count = 0; dup->count = 0; } } @@ -1128,7 +1128,7 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, 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)); + || estimated_freqs_path (rd)); if (do_freqs_to_counts) freqs_to_counts_path (rd); @@ -1139,8 +1139,8 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, 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); + &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++) @@ -1156,7 +1156,7 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, edge victim; edge e2; - gcc_assert (has_joiner); + 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 @@ -1221,7 +1221,7 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, /* 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); + path_out_count); /* Finally, we need to set the probabilities on the duplicated edges out of the duplicated joiner (e2->src). The probabilities @@ -1255,7 +1255,7 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, 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 @@ -1274,9 +1274,9 @@ ssa_fix_duplicate_block_edges (struct redirection_data *rd, } /* Increment the index into the duplicated path when we processed - a duplicated block. */ + a duplicated block. */ if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK - || (*path)[i]->type == EDGE_COPY_SRC_BLOCK) + || (*path)[i]->type == EDGE_COPY_SRC_BLOCK) { count++; } @@ -1320,7 +1320,7 @@ ssa_create_duplicates (struct redirection_data **slot, || (*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) { create_block_for_threading ((*path)[i]->e->src, rd, 1, - &local_info->duplicate_blocks); + &local_info->duplicate_blocks); break; } } @@ -1330,7 +1330,7 @@ ssa_create_duplicates (struct redirection_data **slot, if (local_info->template_block == NULL) { create_block_for_threading ((*path)[1]->e->src, rd, 0, - &local_info->duplicate_blocks); + &local_info->duplicate_blocks); local_info->template_block = rd->dup_blocks[0]; /* We do not create any outgoing edges for the template. We will @@ -1340,7 +1340,7 @@ ssa_create_duplicates (struct redirection_data **slot, else { create_block_for_threading (local_info->template_block, rd, 0, - &local_info->duplicate_blocks); + &local_info->duplicate_blocks); /* Go ahead and wire up outgoing edges and update PHIs for the duplicate block. */ @@ -2156,20 +2156,20 @@ mark_threaded_blocks (bitmap threaded_blocks) vec *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) + if ((*path)[0]->e->aux == NULL) { - (*path)[0]->e->aux = path; + (*path)[0]->e->aux = path; } else { paths.unordered_remove (i); if (dump_file && (dump_flags & TDF_DETAILS)) - dump_jump_thread_path (dump_file, *path, false); + dump_jump_thread_path (dump_file, *path, false); delete_jump_thread_path (path); } - } + } } /* Second, look for paths that have any other jump thread attached to them, and either finish converting them or cancel them. */ @@ -2194,7 +2194,7 @@ mark_threaded_blocks (bitmap threaded_blocks) e->aux = NULL; paths.unordered_remove (i); if (dump_file && (dump_flags & TDF_DETAILS)) - dump_jump_thread_path (dump_file, *path, false); + dump_jump_thread_path (dump_file, *path, false); delete_jump_thread_path (path); } } @@ -2714,13 +2714,13 @@ thread_through_all_blocks (bool may_peel_loop_headers) } /* Our path is still valid, thread it. */ - if (e->aux) + if (e->aux) { if (thread_block ((*path)[0]->e->dest, false)) e->aux = NULL; else { - delete_jump_thread_path (path); + delete_jump_thread_path (path); e->aux = NULL; ei_next (&ei); }