From 391886c8e0153d41b3ab4daf4d2dd1d923d9c50f Mon Sep 17 00:00:00 2001 From: Richard Guenther Date: Mon, 13 Aug 2012 13:49:54 +0000 Subject: [PATCH] basic-block.h (struct basic_block): Remove loop_depth member, move flags and index members next to each other. 2012-08-13 Richard Guenther * basic-block.h (struct basic_block): Remove loop_depth member, move flags and index members next to each other. * cfgloop.h (bb_loop_depth): New inline function. * cfghooks.c (split_block): Do not set loop_depth. (duplicate_block): Likewise. * cfgloop.c (flow_loop_nodes_find): Likewise. (flow_loops_find): Likewise. (add_bb_to_loop): Likewise. (remove_bb_from_loops): Likewise. * cfgrtl.c (force_nonfallthru_and_redirect): Likewise. * gimple-streamer-in.c (input_bb): Do not stream loop_depth. * gimple-streamer-out.c (output_bb): Likewise. * bt-load.c: Include cfgloop.h. (migrate_btr_defs): Use bb_loop_depth. * cfg.c (dump_bb_info): Likewise. * final.c (compute_alignments): Likewise. * ira.c (update_equiv_regs): Likewise. * tree-ssa-copy.c (init_copy_prop): Likewise. * tree-ssa-dom.c (loop_depth_of_name): Likewise. * tree-ssa-forwprop.c: Include cfgloop.h. (forward_propagate_addr_expr): Use bb_loop_depth. * tree-ssa-pre.c (insert_into_preds_of_block): Likewise. * tree-ssa-sink.c (select_best_block): Likewise. * ipa-inline-analysis.c: Include cfgloop.h. (estimate_function_body_sizes): Use bb_loop_depth. * Makefile.in (tree-ssa-forwprop.o): Depend on $(CFGLOOP_H). (ipa-inline-analysis.o): Likewise. (bt-load.o): Likewise. * gcc.dg/tree-prof/update-loopch.c: Adjust. From-SVN: r190346 --- gcc/ChangeLog | 31 +++++++++++++++++++ gcc/Makefile.in | 6 ++-- gcc/basic-block.h | 11 +++---- gcc/bt-load.c | 3 +- gcc/cfg.c | 2 +- gcc/cfghooks.c | 2 -- gcc/cfgloop.c | 10 +----- gcc/cfgloop.h | 8 +++++ gcc/cfgrtl.c | 1 - gcc/final.c | 5 +-- gcc/gimple-streamer-in.c | 1 - gcc/gimple-streamer-out.c | 1 - gcc/ipa-inline-analysis.c | 3 +- gcc/ira.c | 4 +-- gcc/testsuite/ChangeLog | 4 +++ .../gcc.dg/tree-prof/update-loopch.c | 2 +- gcc/tree-ssa-copy.c | 2 +- gcc/tree-ssa-dom.c | 2 +- gcc/tree-ssa-forwprop.c | 5 +-- gcc/tree-ssa-pre.c | 2 +- gcc/tree-ssa-sink.c | 6 ++-- 21 files changed, 71 insertions(+), 40 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 54590f2453b..4bad1761ba2 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,34 @@ +2012-08-13 Richard Guenther + + * basic-block.h (struct basic_block): Remove loop_depth + member, move flags and index members next to each other. + * cfgloop.h (bb_loop_depth): New inline function. + * cfghooks.c (split_block): Do not set loop_depth. + (duplicate_block): Likewise. + * cfgloop.c (flow_loop_nodes_find): Likewise. + (flow_loops_find): Likewise. + (add_bb_to_loop): Likewise. + (remove_bb_from_loops): Likewise. + * cfgrtl.c (force_nonfallthru_and_redirect): Likewise. + * gimple-streamer-in.c (input_bb): Do not stream loop_depth. + * gimple-streamer-out.c (output_bb): Likewise. + * bt-load.c: Include cfgloop.h. + (migrate_btr_defs): Use bb_loop_depth. + * cfg.c (dump_bb_info): Likewise. + * final.c (compute_alignments): Likewise. + * ira.c (update_equiv_regs): Likewise. + * tree-ssa-copy.c (init_copy_prop): Likewise. + * tree-ssa-dom.c (loop_depth_of_name): Likewise. + * tree-ssa-forwprop.c: Include cfgloop.h. + (forward_propagate_addr_expr): Use bb_loop_depth. + * tree-ssa-pre.c (insert_into_preds_of_block): Likewise. + * tree-ssa-sink.c (select_best_block): Likewise. + * ipa-inline-analysis.c: Include cfgloop.h. + (estimate_function_body_sizes): Use bb_loop_depth. + * Makefile.in (tree-ssa-forwprop.o): Depend on $(CFGLOOP_H). + (ipa-inline-analysis.o): Likewise. + (bt-load.o): Likewise. + 2012-08-13 Ganesh Gopalasubramanian Jakub Jelinek diff --git a/gcc/Makefile.in b/gcc/Makefile.in index ba0287f38ce..29bd1aa586b 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2271,7 +2271,7 @@ tree-ssa-dse.o : tree-ssa-dse.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TREE_FLOW_H) $(TREE_PASS_H) domwalk.h $(FLAGS_H) \ $(GIMPLE_PRETTY_PRINT_H) langhooks.h tree-ssa-forwprop.o : tree-ssa-forwprop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TM_H) $(TREE_H) $(TM_P_H) $(BASIC_BLOCK_H) \ + $(TM_H) $(TREE_H) $(TM_P_H) $(BASIC_BLOCK_H) $(CFGLOOP_H) \ $(TREE_FLOW_H) $(TREE_PASS_H) $(DIAGNOSTIC_H) \ langhooks.h $(FLAGS_H) $(GIMPLE_H) $(GIMPLE_PRETTY_PRINT_H) $(EXPR_H) tree-ssa-phiprop.o : tree-ssa-phiprop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ @@ -2899,7 +2899,7 @@ ipa-inline.o : ipa-inline.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(EXCEPT_H) $(GIMPLE_PRETTY_PRINT_H) ipa-inline.h $(TARGET_H) $(IPA_UTILS_H) ipa-inline-analysis.o : ipa-inline-analysis.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) langhooks.h $(TREE_INLINE_H) $(FLAGS_H) $(CGRAPH_H) intl.h \ - $(DIAGNOSTIC_H) $(PARAMS_H) $(TREE_PASS_H) \ + $(DIAGNOSTIC_H) $(PARAMS_H) $(TREE_PASS_H) $(CFGLOOP_H) \ $(HASHTAB_H) $(COVERAGE_H) $(GGC_H) $(TREE_FLOW_H) $(IPA_PROP_H) \ $(GIMPLE_PRETTY_PRINT_H) ipa-inline.h $(LTO_STREAMER_H) $(DATA_STREAMER_H) \ $(TREE_STREAMER_H) @@ -3183,7 +3183,7 @@ caller-save.o : caller-save.c $(CONFIG_H) $(SYSTEM_H) coretypes.h dumpfile.h \ bt-load.o : bt-load.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(EXCEPT_H) \ $(RTL_H) hard-reg-set.h $(REGS_H) $(TM_P_H) $(FIBHEAP_H) $(EXPR_H) \ $(TARGET_H) $(FLAGS_H) $(INSN_ATTR_H) $(FUNCTION_H) $(TREE_PASS_H) \ - $(DIAGNOSTIC_CORE_H) $(DF_H) vecprim.h $(RECOG_H) + $(DIAGNOSTIC_CORE_H) $(DF_H) vecprim.h $(RECOG_H) $(CFGLOOP_H) reorg.o : reorg.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \ conditions.h hard-reg-set.h $(BASIC_BLOCK_H) $(REGS_H) insn-config.h \ $(INSN_ATTR_H) $(EXCEPT_H) $(RECOG_H) $(FUNCTION_H) $(FLAGS_H) output.h \ diff --git a/gcc/basic-block.h b/gcc/basic-block.h index dff06e4e69f..8183ce2e3c7 100644 --- a/gcc/basic-block.h +++ b/gcc/basic-block.h @@ -160,14 +160,14 @@ struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_d } GTY ((tag ("1"))) x; } GTY ((desc ("((%1.flags & BB_RTL) != 0)"))) il; - /* Expected number of executions: calculated in profile.c. */ - gcov_type count; + /* Various flags. See cfg-flags.def. */ + int flags; /* The index of this block. */ int index; - /* The loop depth of this block. */ - int loop_depth; + /* Expected number of executions: calculated in profile.c. */ + gcov_type count; /* Expected frequency. Normalized to be in range 0 to BB_FREQ_MAX. */ int frequency; @@ -176,9 +176,6 @@ struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_d among several basic blocks that share a common locus, allowing for more accurate sample-based profiling. */ int discriminator; - - /* Various flags. See cfg-flags.def. */ - int flags; }; /* This ensures that struct gimple_bb_info is smaller than diff --git a/gcc/bt-load.c b/gcc/bt-load.c index 2cab03cc86e..385bc6c45ac 100644 --- a/gcc/bt-load.c +++ b/gcc/bt-load.c @@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "recog.h" #include "df.h" +#include "cfgloop.h" /* Target register optimizations - these are performed after reload. */ @@ -1408,7 +1409,7 @@ migrate_btr_defs (enum reg_class btr_class, int allow_callee_save) fprintf(dump_file, "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC " loop-depth = %d idom = %d\n", - i, (HOST_WIDEST_INT) bb->count, bb->loop_depth, + i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb), get_immediate_dominator (CDI_DOMINATORS, bb)->index); } } diff --git a/gcc/cfg.c b/gcc/cfg.c index 2b4e9085068..ba8320812cd 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -698,7 +698,7 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, if (flags & TDF_COMMENT) fputs (";; ", outf); fprintf (outf, "%sbasic block %d, loop depth %d", - s_indent, bb->index, bb->loop_depth); + s_indent, bb->index, bb_loop_depth (bb)); if (flags & TDF_DETAILS) { fprintf (outf, ", count " HOST_WIDEST_INT_PRINT_DEC, diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index a7b653b220c..1417e48299d 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -462,7 +462,6 @@ split_block (basic_block bb, void *i) new_bb->count = bb->count; new_bb->frequency = bb->frequency; - new_bb->loop_depth = bb->loop_depth; new_bb->discriminator = bb->discriminator; if (dom_info_available_p (CDI_DOMINATORS)) @@ -985,7 +984,6 @@ duplicate_block (basic_block bb, edge e, basic_block after) if (after) move_block_after (new_bb, after); - new_bb->loop_depth = bb->loop_depth; new_bb->flags = bb->flags; FOR_EACH_EDGE (s, ei, bb->succs) { diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c index 95c173ae3bf..0c51682897e 100644 --- a/gcc/cfgloop.c +++ b/gcc/cfgloop.c @@ -229,10 +229,8 @@ flow_loop_nodes_find (basic_block header, struct loop *loop) int num_nodes = 1; edge latch; edge_iterator latch_ei; - unsigned depth = loop_depth (loop); header->loop_father = loop; - header->loop_depth = depth; FOR_EACH_EDGE (latch, latch_ei, loop->header->preds) { @@ -243,7 +241,6 @@ flow_loop_nodes_find (basic_block header, struct loop *loop) num_nodes++; VEC_safe_push (basic_block, heap, stack, latch->src); latch->src->loop_father = loop; - latch->src->loop_depth = depth; while (!VEC_empty (basic_block, stack)) { @@ -260,7 +257,6 @@ flow_loop_nodes_find (basic_block header, struct loop *loop) if (ancestor->loop_father != loop) { ancestor->loop_father = loop; - ancestor->loop_depth = depth; num_nodes++; VEC_safe_push (basic_block, heap, stack, ancestor); } @@ -365,7 +361,7 @@ init_loops_structure (struct loops *loops, unsigned num_loops) } /* Find all the natural loops in the function and save in LOOPS structure and - recalculate loop_depth information in basic block structures. + recalculate loop_father information in basic block structures. Return the number of natural loops found. */ int @@ -404,8 +400,6 @@ flow_loops_find (struct loops *loops) { edge_iterator ei; - header->loop_depth = 0; - /* If we have an abnormal predecessor, do not consider the loop (not worth the problems). */ if (bb_has_abnormal_pred (header)) @@ -1185,7 +1179,6 @@ add_bb_to_loop (basic_block bb, struct loop *loop) gcc_assert (bb->loop_father == NULL); bb->loop_father = loop; - bb->loop_depth = loop_depth (loop); loop->num_nodes++; FOR_EACH_VEC_ELT (loop_p, loop->superloops, i, ploop) ploop->num_nodes++; @@ -1215,7 +1208,6 @@ remove_bb_from_loops (basic_block bb) FOR_EACH_VEC_ELT (loop_p, loop->superloops, i, ploop) ploop->num_nodes--; bb->loop_father = NULL; - bb->loop_depth = 0; FOR_EACH_EDGE (e, ei, bb->succs) { diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h index 239eb595dae..5c03390ab25 100644 --- a/gcc/cfgloop.h +++ b/gcc/cfgloop.h @@ -445,6 +445,14 @@ loop_depth (const struct loop *loop) return VEC_length (loop_p, loop->superloops); } +/* Returns the loop depth of the loop BB belongs to. */ + +static inline int +bb_loop_depth (const_basic_block bb) +{ + return bb->loop_father ? loop_depth (bb->loop_father) : 0; +} + /* Returns the immediate superloop of LOOP, or NULL if LOOP is the outermost loop. */ diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c index feff53d2111..c62b5bce33f 100644 --- a/gcc/cfgrtl.c +++ b/gcc/cfgrtl.c @@ -1438,7 +1438,6 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label) jump_block = create_basic_block (note, NULL, e->src); jump_block->count = count; jump_block->frequency = EDGE_FREQUENCY (e); - jump_block->loop_depth = target->loop_depth; /* Make sure new block ends up in correct hot/cold section. */ diff --git a/gcc/final.c b/gcc/final.c index 30890b3ce22..ed8624ee600 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -739,7 +739,8 @@ compute_alignments (void) { if (dump_file) fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n", - bb->index, bb->frequency, bb->loop_father->num, bb->loop_depth); + bb->index, bb->frequency, bb->loop_father->num, + bb_loop_depth (bb)); continue; } max_log = LABEL_ALIGN (label); @@ -756,7 +757,7 @@ compute_alignments (void) { fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i fall %4i branch %4i", bb->index, bb->frequency, bb->loop_father->num, - bb->loop_depth, + bb_loop_depth (bb), fallthru_frequency, branch_frequency); if (!bb->loop_father->inner && bb->loop_father->num) fprintf (dump_file, " inner_loop"); diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c index 56cdc6f4f67..e2934c7fa8d 100644 --- a/gcc/gimple-streamer-in.c +++ b/gcc/gimple-streamer-in.c @@ -296,7 +296,6 @@ input_bb (struct lto_input_block *ib, enum LTO_tags tag, bb->count = (streamer_read_hwi (ib) * count_materialization_scale + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE; - bb->loop_depth = streamer_read_hwi (ib); bb->frequency = streamer_read_hwi (ib); bb->flags = streamer_read_hwi (ib); diff --git a/gcc/gimple-streamer-out.c b/gcc/gimple-streamer-out.c index a7e73fa8db2..b7e840844da 100644 --- a/gcc/gimple-streamer-out.c +++ b/gcc/gimple-streamer-out.c @@ -176,7 +176,6 @@ output_bb (struct output_block *ob, basic_block bb, struct function *fn) streamer_write_uhwi (ob, bb->index); streamer_write_hwi (ob, bb->count); - streamer_write_hwi (ob, bb->loop_depth); streamer_write_hwi (ob, bb->frequency); streamer_write_hwi (ob, bb->flags); diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index f19f1f78d5a..bf4d42a1fa9 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -87,6 +87,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-streamer.h" #include "ipa-inline.h" #include "alloc-pool.h" +#include "cfgloop.h" /* Estimate runtime of function can easilly run into huge numbers with many nested loops. Be sure we can compute time * INLINE_SIZE_SCALE * 2 in an @@ -2088,7 +2089,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) es->call_stmt_size = this_size; es->call_stmt_time = this_time; - es->loop_depth = bb->loop_depth; + es->loop_depth = bb_loop_depth (bb); edge_set_predicate (edge, &bb_predicate); } diff --git a/gcc/ira.c b/gcc/ira.c index 6699d2bacf7..a209894efbe 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -2777,7 +2777,7 @@ update_equiv_regs (void) a register can be set below its use. */ FOR_EACH_BB (bb) { - loop_depth = bb->loop_depth; + loop_depth = bb_loop_depth (bb); for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb)); @@ -3053,7 +3053,7 @@ update_equiv_regs (void) basic block. */ FOR_EACH_BB_REVERSE (bb) { - loop_depth = bb->loop_depth; + loop_depth = bb_loop_depth (bb); for (insn = BB_END (bb); insn != PREV_INSN (BB_HEAD (bb)); insn = PREV_INSN (insn)) diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index f09347af0d7..1117d9a6f24 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2012-08-13 Richard Guenther + + * gcc.dg/tree-prof/update-loopch.c: Adjust. + 2012-08-13 Richard Guenther PR tree-optimization/54200 diff --git a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c index cc06ea7396b..e2656a30645 100644 --- a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c +++ b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c @@ -14,7 +14,7 @@ main () /* Loop header copying will peel away the initial conditional, so the loop body is once reached directly from entry point of function, rest via loopback edge. */ -/* { dg-final-use { scan-ipa-dump "loop depth 1, count 33334" "profile"} } */ +/* { dg-final-use { scan-ipa-dump "loop depth 0, count 33334" "profile"} } */ /* { dg-final-use { scan-tree-dump "loop depth 1, count 33332" "optimized"} } */ /* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */ /* { dg-final-use { cleanup-ipa-dump "profile" } } */ diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c index c5fe156ce9a..b53abb1d0d2 100644 --- a/gcc/tree-ssa-copy.c +++ b/gcc/tree-ssa-copy.c @@ -670,7 +670,7 @@ init_copy_prop (void) FOR_EACH_BB (bb) { gimple_stmt_iterator si; - int depth = bb->loop_depth; + int depth = bb_loop_depth (bb); for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index d2a41284a2f..f70dcc842da 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -1391,7 +1391,7 @@ loop_depth_of_name (tree x) if (!defbb) return 0; - return defbb->loop_depth; + return bb_loop_depth (defbb); } /* Record that X is equal to Y in const_and_copies. Record undo diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index 662fe49bb83..78e17a55582 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -32,6 +32,7 @@ along with GCC; see the file COPYING3. If not see #include "flags.h" #include "gimple.h" #include "expr.h" +#include "cfgloop.h" /* This pass propagates the RHS of assignment statements into use sites of the LHS of the assignment. It's basically a specialized @@ -1002,7 +1003,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, static bool forward_propagate_addr_expr (tree name, tree rhs) { - int stmt_loop_depth = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_depth; + int stmt_loop_depth = bb_loop_depth (gimple_bb (SSA_NAME_DEF_STMT (name))); imm_use_iterator iter; gimple use_stmt; bool all = true; @@ -1025,7 +1026,7 @@ forward_propagate_addr_expr (tree name, tree rhs) /* If the use is in a deeper loop nest, then we do not want to propagate non-invariant ADDR_EXPRs into the loop as that is likely adding expression evaluations into the loop. */ - if (gimple_bb (use_stmt)->loop_depth > stmt_loop_depth + if (bb_loop_depth (gimple_bb (use_stmt)) > stmt_loop_depth && !is_gimple_min_invariant (rhs)) { all = false; diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 9b186ddc577..47df596ee6c 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -3204,7 +3204,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, gimple phi; /* Make sure we aren't creating an induction variable. */ - if (block->loop_depth > 0 && EDGE_COUNT (block->preds) == 2) + if (bb_loop_depth (block) > 0 && EDGE_COUNT (block->preds) == 2) { bool firstinsideloop = false; bool secondinsideloop = false; diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c index b5495e7558a..2d2c370201f 100644 --- a/gcc/tree-ssa-sink.c +++ b/gcc/tree-ssa-sink.c @@ -212,7 +212,7 @@ select_best_block (basic_block early_bb, { /* If we've moved into a lower loop nest, then that becomes our best block. */ - if (temp_bb->loop_depth < best_bb->loop_depth) + if (bb_loop_depth (temp_bb) < bb_loop_depth (best_bb)) best_bb = temp_bb; /* Walk up the dominator tree, hopefully we'll find a shallower @@ -223,7 +223,7 @@ select_best_block (basic_block early_bb, /* If we found a shallower loop nest, then we always consider that a win. This will always give us the most control dependent block within that loop nest. */ - if (best_bb->loop_depth < early_bb->loop_depth) + if (bb_loop_depth (best_bb) < bb_loop_depth (early_bb)) return best_bb; /* Get the sinking threshold. If the statement to be moved has memory @@ -239,7 +239,7 @@ select_best_block (basic_block early_bb, /* If BEST_BB is at the same nesting level, then require it to have significantly lower execution frequency to avoid gratutious movement. */ - if (best_bb->loop_depth == early_bb->loop_depth + if (bb_loop_depth (best_bb) == bb_loop_depth (early_bb) && best_bb->frequency < (early_bb->frequency * threshold / 100.0)) return best_bb;