Patch, RFC: remove unused find_basic_blocks

Laurynas Biveinis laurynas.biveinis@gmail.com
Wed Sep 12 00:31:00 GMT 2007


Hello,

I've noticed that cfgbuild.c:find_basic_blocks in is used only inside
"#if 0" block in sh.c and a few obviously outdated comments. So this
patch removes find_basic_blocks and its subroutines. Also I took
liberty to remove the whole involved #if 0 block from sh.c

But I have no idea how to update the comments mentioning it, could
somebody help here? Thanks.

They are: except.c:finish_eh_generation:

  /* The object here is to provide find_basic_blocks with detailed
     information (via reachable_handlers) on how exception control
     flows within the function.  In this first pass, we can include
     type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
     regions, and hope that it will be useful in deleting unreachable
     handlers.  Subsequently, we will generate landing pads which will
     connect many of the handlers, and then type information will not
     be effective.  Still, this is a win over previous implementations.  */

And before cfghooks.c:tidy_fallthru_edges:

/* Fix up edges that now fall through, or rather should now fall through
   but previously required a jump around now deleted blocks.  Simplify
   the search by only examining blocks numerically adjacent, since this
   is how find_basic_blocks created them.  */


Tested by bootstrapping i686-pc-linux-gnu, regtest in progress (I
cannot imagine how it could possibly break something, but still), and
by "make sh.o".

This change does not help the 4.3 release in any way, so I'm not
suggesting it for stage 3 mainline and going to commit it to gc-improv
until stage 1/2.

2007-09-11  Laurynas Biveinis  <laurynas.biveinis@gmail.com>

         * cfgbuild.c: Remove comment about find_basic_blocks.
         (count_basic_blocks): Remove.
         (find_basic_blocks_1): Remove.
         (find_basic_blocks): Remove.
         * basic-block.h (find_basic_blocks):  Remove prototype.
         * config/sh/sh.c (sh_output_mi_thunk):  Remove the #if 0 block
         that references find_basic_blocks.
         * except.c (finish_eh_generation):  Make static.
         * except.h (finish_eh_generation):  Remove prototype.

-- 
Laurynas

Index: cfgbuild.c
===================================================================
--- cfgbuild.c  (revision 128348)
+++ cfgbuild.c  (working copy)
@@ -18,17 +18,6 @@
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */

-/* find_basic_blocks divides the current function's rtl into basic
-   blocks and constructs the CFG.  The blocks are recorded in the
-   basic_block_info array; the CFG exists in the edge structures
-   referenced by the blocks.
-
-   find_basic_blocks also finds any unreachable loops and deletes them.
-
-   Available functionality:
-     - CFG construction
-        find_basic_blocks  */
-

 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
@@ -45,8 +34,6 @@
 #include "toplev.h"
 #include "timevar.h"

-static int count_basic_blocks (const_rtx);
-static void find_basic_blocks_1 (rtx);
 static void make_edges (basic_block, basic_block, int);
 static void make_label_edge (sbitmap, basic_block, rtx, int);
 static void find_bb_boundaries (basic_block);
@@ -137,45 +124,6 @@
     }
 }

-/* Count the basic blocks of the function.  */
-
-static int
-count_basic_blocks (const_rtx f)
-{
-  int count = NUM_FIXED_BLOCKS;
-  bool saw_insn = false;
-  const_rtx insn;
-
-  for (insn = f; insn; insn = NEXT_INSN (insn))
-    {
-      /* Code labels and barriers causes current basic block to be
-        terminated at previous real insn.  */
-      if ((LABEL_P (insn) || BARRIER_P (insn))
-         && saw_insn)
-       count++, saw_insn = false;
-
-      /* Start basic block if needed.  */
-      if (!saw_insn && inside_basic_block_p (insn))
-       saw_insn = true;
-
-      /* Control flow insn causes current basic block to be terminated.  */
-      if (saw_insn && control_flow_insn_p (insn))
-       count++, saw_insn = false;
-    }
-
-  if (saw_insn)
-    count++;
-
-  /* The rest of the compiler works a bit smoother when we don't have to
-     check for the edge case of do-nothing functions with no basic blocks.  */
-  if (count == NUM_FIXED_BLOCKS)
-    {
-      emit_insn (gen_rtx_USE (VOIDmode, const0_rtx));
-      count = NUM_FIXED_BLOCKS + 1;
-    }
-
-  return count;
-}


 /* Create an edge between two basic blocks.  FLAGS are auxiliary information
    about the edge that is accumulated between calls.  */
@@ -417,158 +365,7 @@
     sbitmap_vector_free (edge_cache);
 }


-/* Find all basic blocks of the function whose first insn is F.
-
-   Collect and return a list of labels whose addresses are taken.  This
-   will be used in make_edges for use with computed gotos.  */
-
 static void
-find_basic_blocks_1 (rtx f)
-{
-  rtx insn, next;
-  rtx bb_note = NULL_RTX;
-  rtx head = NULL_RTX;
-  rtx end = NULL_RTX;
-  basic_block prev = ENTRY_BLOCK_PTR;
-
-  /* We process the instructions in a slightly different way than we did
-     previously.  This is so that we see a NOTE_BASIC_BLOCK after we have
-     closed out the previous block, so that it gets attached at the proper
-     place.  Since this form should be equivalent to the previous,
-     count_basic_blocks continues to use the old form as a check.  */
-
-  for (insn = f; insn; insn = next)
-    {
-      enum rtx_code code = GET_CODE (insn);
-
-      next = NEXT_INSN (insn);
-
-      if ((LABEL_P (insn) || BARRIER_P (insn))
-         && head)
-       {
-         prev = create_basic_block_structure (head, end, bb_note, prev);
-         head = end = NULL_RTX;
-         bb_note = NULL_RTX;
-       }
-
-      if (inside_basic_block_p (insn))
-       {
-         if (head == NULL_RTX)
-           head = insn;
-         end = insn;
-       }
-
-      if (head && control_flow_insn_p (insn))
-       {
-         prev = create_basic_block_structure (head, end, bb_note, prev);
-         head = end = NULL_RTX;
-         bb_note = NULL_RTX;
-       }
-
-      switch (code)
-       {
-       case NOTE:
-         /* Look for basic block notes with which to keep the
-            basic_block_info pointers stable.  Unthread the note now;
-            we'll put it back at the right place in create_basic_block.
-            Or not at all if we've already found a note in this block.  */
-         if (NOTE_INSN_BASIC_BLOCK_P (insn))
-           {
-             if (bb_note == NULL_RTX)
-               bb_note = insn;
-             else
-               next = delete_insn (insn);
-           }
-         break;
-
-       case CODE_LABEL:
-       case JUMP_INSN:
-       case CALL_INSN:
-       case INSN:
-       case BARRIER:
-         break;
-
-       default:
-         gcc_unreachable ();
-       }
-    }
-
-  if (head != NULL_RTX)
-    create_basic_block_structure (head, end, bb_note, prev);
-  else if (bb_note)
-    delete_insn (bb_note);
-
-  gcc_assert (last_basic_block == n_basic_blocks);
-
-  clear_aux_for_blocks ();
-}
-
-
-/* Find basic blocks of the current function.
-   F is the first insn of the function.  */
-
-void
-find_basic_blocks (rtx f)
-{
-  basic_block bb;
-
-  timevar_push (TV_CFG);
-
-  /* Flush out existing data.  */
-  if (basic_block_info != NULL)
-    {
-      clear_edges ();
-
-      /* Clear bb->aux on all extant basic blocks.  We'll use this as a
-        tag for reuse during create_basic_block, just in case some pass
-        copies around basic block notes improperly.  */
-      FOR_EACH_BB (bb)
-       bb->aux = NULL;
-
-      basic_block_info = NULL;
-    }
-
-  n_basic_blocks = count_basic_blocks (f);
-  last_basic_block = NUM_FIXED_BLOCKS;
-  ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
-  EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
-
-
-  /* Size the basic block table.  The actual structures will be allocated
-     by find_basic_blocks_1, since we want to keep the structure pointers
-     stable across calls to find_basic_blocks.  */
-  /* ??? This whole issue would be much simpler if we called find_basic_blocks
-     exactly once, and thereafter we don't have a single long chain of
-     instructions at all until close to the end of compilation when we
-     actually lay them out.  */
-
-  basic_block_info = VEC_alloc (basic_block, gc, n_basic_blocks);
-  VEC_safe_grow_cleared (basic_block, gc, basic_block_info, n_basic_blocks);
-  SET_BASIC_BLOCK (ENTRY_BLOCK, ENTRY_BLOCK_PTR);
-  SET_BASIC_BLOCK (EXIT_BLOCK, EXIT_BLOCK_PTR);
-
-  find_basic_blocks_1 (f);
-
-  profile_status = PROFILE_ABSENT;
-
-  /* Tell make_edges to examine every block for out-going edges.  */
-  FOR_EACH_BB (bb)
-    SET_STATE (bb, BLOCK_NEW);
-
-  /* Discover the edges of our cfg.  */
-  make_edges (ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR->prev_bb, 0);
-
-  /* Do very simple cleanup now, for the benefit of code that runs between
-     here and cleanup_cfg, e.g. thread_prologue_and_epilogue_insns.  */
-  tidy_fallthru_edges ();
-
-#ifdef ENABLE_CHECKING
-  verify_flow_info ();
-#endif
-  timevar_pop (TV_CFG);
-}
-

-static void
 mark_tablejump_edge (rtx label)
 {
   basic_block bb;
Index: except.c
===================================================================
--- except.c    (revision 128348)
+++ except.c    (working copy)
@@ -2069,7 +2069,7 @@
   free (lp_info);
 }

-void
+static void
 finish_eh_generation (void)
 {
   basic_block bb;
Index: except.h
===================================================================
--- except.h    (revision 128348)
+++ except.h    (working copy)
@@ -53,10 +53,6 @@
 /* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls.  */
 extern unsigned int set_nothrow_function_flags (void);

-/* After initial rtl generation, call back to finish generating
-   exception support code.  */
-extern void finish_eh_generation (void);
-
 extern void init_eh (void);
 extern void init_eh_for_function (void);

Index: basic-block.h
===================================================================
--- basic-block.h       (revision 128348)
+++ basic-block.h       (working copy)
@@ -879,7 +879,6 @@
 /* In cfgbuild.c.  */
 extern void find_many_sub_basic_blocks (sbitmap);
 extern void rtl_make_eh_edge (sbitmap, basic_block, rtx);
-extern void find_basic_blocks (rtx);

 /* In cfgcleanup.c.  */
 extern bool cleanup_cfg (int);
Index: config/sh/sh.c
===================================================================
--- config/sh/sh.c      (revision 128348)
+++ config/sh/sh.c      (working copy)
@@ -10213,41 +10213,12 @@
   insn_locators_alloc ();
   insns = get_insns ();

-#if 0
   if (optimize > 0)
     {
-      /* Initialize the bitmap obstacks.  */
-      bitmap_obstack_initialize (NULL);
-      bitmap_obstack_initialize (&reg_obstack);
       if (! cfun->cfg)
        init_flow ();
-      rtl_register_cfg_hooks ();
-      init_rtl_bb_info (ENTRY_BLOCK_PTR);
-      init_rtl_bb_info (EXIT_BLOCK_PTR);
-      ENTRY_BLOCK_PTR->flags |= BB_RTL;
-      EXIT_BLOCK_PTR->flags |= BB_RTL;
-      find_basic_blocks (insns);
-
-      if (flag_schedule_insns_after_reload)
-       {
-         life_analysis (PROP_FINAL);
-
-         split_all_insns (1);
-
-         schedule_insns ();
-       }
-      /* We must split jmp insn in PIC case.  */
-      else if (flag_pic)
-       split_all_insns_noflow ();
-    }
-#else
-  if (optimize > 0)
-    {
-      if (! cfun->cfg)
-       init_flow ();
       split_all_insns_noflow ();
     }
-#endif

   sh_reorg ();



More information about the Gcc-patches mailing list