PATCH: delete find_basic_blocks

[Laurynas Biveinis <laurynas dot biveinis at gmail dot com>]

Besides two references in comments and one #if 0'ed piece of code,
nobody calls this function anymore.

This patch deletes it and its associated static functions and updates
those comments to the best of my knowledge. One of the comments
belongs to finish_eh_generation in except.c, which is only used in
that file, thus the patch makes it static.

Bootstrapped under x86_64-unknown-linux-gnu, testsuite was not run.
The SH part was tested by configuring with --host=sh-unknown-linux and
then make sh.o.

The SH part was approved in summer 2007, is everything else OK for trunk?

Thanks.

2009-04-21  Laurynas Biveinis  <laurynas.biveinis@gmail.com>

	    * cfghooks.c (tidy_fallthru_edges):  Remove find_basic_blocks
	    references from comments.
	    * cfgbuild.c (count_basic_blocks): Delete.
	    (find_basic_blocks_1): Delete.
	    (find_basic_blocks): Delete.
	    * except.c (finish_eh_generation): Make static.  Move comment
	    from except.h here.  Remove find_basic_blocks references from
	    comments.
	    * except.h (finish_eh_generation): Delete.
	    * basic-block.h (find_basic_blocks): Delete.
	    * config/sh/sh.c (sh_output_mi_thunk): Delete a "#if 0" block.

-- 
Laurynas

2009-04-21  Laurynas Biveinis  <laurynas.biveinis@gmail.com>

	    * cfghooks.c (tidy_fallthru_edges):  Remove find_basic_blocks
	    references from comments.
	    * cfguilb.c: (count_basic_blocks): Delete.
	    (find_basic_blocks_1): Delete.
	    (find_basic_blocks): Delete.
	    * except.c (finish_eh_generation): Make static.  Move comment
	    from except.h here.  Remove find_basic_blocks references from 
	    comments.
	    * except.h (finish_eh_generation): Delete.
	    * basic-block.h (find_basic_blocks): Delete.
	    * config/sh/sh.c (sh_output_mi_thunk): Delete a "#if 0" block.

Index: cfghooks.c
===================================================================
--- cfghooks.c	(revision 146451)
+++ cfghooks.c	(working copy)
@@ -829,7 +829,7 @@
 /* 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.  */
+   is how they were created.  */
 
 void
 tidy_fallthru_edges (void)
@@ -852,9 +852,9 @@
 	 a single successor.
 
 	 If we had a conditional branch to the next instruction when
-	 find_basic_blocks was called, then there will only be one
-	 out edge for the block which ended with the conditional
-	 branch (since we do not create duplicate edges).
+	 CFG was build, then there will only be one out edge for the
+	 block which ended with the conditional branch (since we do
+	 not create duplicate edges).
 
 	 Furthermore, the edge will be marked as a fallthru because we
 	 merge the flags for the duplicate edges.  So we do not want to
Index: cfgbuild.c
===================================================================
--- cfgbuild.c	(revision 146451)
+++ cfgbuild.c	(working copy)
@@ -19,16 +19,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"
@@ -46,8 +36,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);
@@ -138,45 +126,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_use (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.  */
@@ -418,158 +367,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 146451)
+++ except.c	(working copy)
@@ -2117,7 +2117,10 @@
   free (lp_info);
 }
 
-void
+/* After initial rtl generation, call back to finish generating
+   exception support code.  */
+
+static void
 finish_eh_generation (void)
 {
   basic_block bb;
@@ -2126,14 +2129,15 @@
   if (cfun->eh->region_tree == NULL)
     return;
 
-  /* 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.  */
+  /* The object here is to provide detailed information (via
+     reachable_handlers) on how exception control flows within the
+     function for the CFG construction.  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.  */
 
   /* These registers are used by the landing pads.  Make sure they
      have been generated.  */
Index: except.h
===================================================================
--- except.h	(revision 146451)
+++ except.h	(working copy)
@@ -151,10 +151,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 146451)
+++ basic-block.h	(working copy)
@@ -896,7 +896,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 146451)
+++ config/sh/sh.c	(working copy)
@@ -10634,41 +10634,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 (cfun);
       split_all_insns_noflow ();
     }
-#endif
 
   sh_reorg ();