2012-08-13 Richard Guenther <rguenther@suse.de>

	* 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.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@190346 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 54590f2453b35cc6962d906f4c9168733edf7841..4bad1761ba2e743f102674a6c9a2979d2d8690a6 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,34 @@
+2012-08-13  Richard Guenther  <rguenther@suse.de>
+
+       * 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  <Ganesh.Gopalasubramanian@amd.com>
            Jakub Jelinek  <jakub@redhat.com>
 

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index ba0287f38cecd40e36a11f6e89e4bfc414be1f9a..29bd1aa586b8e8a41c7dbcb5928f6a71d0e027fe 100644 (file)
--- 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 dff06e4e69f9beac6171c7b1d29692835abf9310..8183ce2e3c7ff5c3a7350774843d2bd6440ee786 100644 (file)
--- 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 2cab03cc86e44258e3a3bc307f315deda4f3125f..385bc6c45ac3f8fa92d7a55a34fc72780b8ec68c 100644 (file)
--- 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 2b4e90850683a4a1ed821781184b9443222cbf03..ba8320812cd123053fc63dc011211b8976995369 100644 (file)
--- 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 a7b653b220c3c0bafb991a75d779511ebafa87f9..1417e48299d52de55177f084d113470f566d7271 100644 (file)
--- 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 95c173ae3bfd5dbb5d75e7871ccefa62b718e2d3..0c51682897e79a7f47de3de523aa44fe90e946d9 100644 (file)
--- 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 239eb595dae247326ac181f1767ef25ba8ee279c..5c03390ab253d9d19859589048ac90444e1cac2b 100644 (file)
--- 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 feff53d21115251844834eb520749acf727d238a..c62b5bce33fbe9beb6a80b46496069d68849c43e 100644 (file)
--- 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 30890b3ce223df7a918691583b9adf6b9515eef4..ed8624ee600964b9886c083fc3115c520366ea36 100644 (file)
--- 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 56cdc6f4f67ce58d4920333489159d663aad8151..e2934c7fa8db5245efdcbb377dd44f6529f54704 100644 (file)
--- 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 a7e73fa8db25f9e32fc017e8f0cf05f3235779f4..b7e840844da9bf675215654a28922bdaa1bec8f9 100644 (file)
--- 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 f19f1f78d5a9264f36afb033d1c44a0062cdfe61..bf4d42a1fa991574ed567d74d0835fa2705753c7 100644 (file)
--- 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 6699d2bacf7127010c2a690947e901173ae9c502..a209894efbe6e06bce4727e72843dd7b9e95f31d 100644 (file)
--- 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 f09347af0d7596e5e6f1979b7b29c37f8fc807e5..1117d9a6f2454e853ff8412e2db835feb050ad93 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2012-08-13  Richard Guenther  <rguenther@suse.de>
+
+       * gcc.dg/tree-prof/update-loopch.c: Adjust.
+
 2012-08-13  Richard Guenther  <rguenther@suse.de>
 
        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 cc06ea7396bdb57ab8c727c3795853ae1c54ccd7..e2656a30645bd6d05f808b160f79ba1bba1b674d 100644 (file)
--- 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 c5fe156ce9ae6853c03a175540a68c2ee1b8660b..b53abb1d0d228a028bbbe536ffd2d01eb4a9d7d8 100644 (file)
--- 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 d2a41284a2f80a24cdfda648e01e09abffe4af8b..f70dcc842da5abac2cce6deead3576fffb3f3da5 100644 (file)
--- 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 662fe49bb83c5d5b4b51264f7778258de486e7e5..78e17a55582dbb6cd75e1ed40802a170a5f993b7 100644 (file)
--- 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 9b186ddc577479f3dbb12782e9ec0c6308ec50f4..47df596ee6c2390ad5f8bfacd0282ac870591c03 100644 (file)
--- 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 b5495e7558aa6e322724ae59e6856a964598ae27..2d2c370201fdcbc608b2e98bfcb90d4660498534 100644 (file)
--- 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;