2009-04-22 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.



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

7 files changed, 31 insertions, 249 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c33e2d95f07..26b721b5e85 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2009-04-22  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.
+
 2009-04-22  Dave Korn  <dave.korn.cygwin@gmail.com>
 
 	* sdbout.c (sdbout_symbol):  Pass VOIDmode to eliminate_regs.
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index dfde67391d4..198fbefc0eb 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -896,7 +896,6 @@ extern bool purge_dead_edges (basic_block);
 /* 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);
diff --git a/gcc/cfgbuild.c b/gcc/cfgbuild.c
index 519108e51dc..1c91ddbf32d 100644
--- a/gcc/cfgbuild.c
+++ b/gcc/cfgbuild.c
@@ -19,16 +19,6 @@ You should have received a copy of the GNU General Public License
 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 @@ along with GCC; see the file COPYING3.  If not see
 #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 @@ control_flow_insn_p (const_rtx insn)
     }
 }
 
-/* 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,157 +367,6 @@ make_edges (basic_block min, basic_block max, int update_p)
     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)
 {
diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 10c04a8b057..2c65726fe17 100644
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -829,7 +829,7 @@ tidy_fallthru_edge (edge e)
 /* 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 @@ tidy_fallthru_edges (void)
 	 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 built, 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
diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c
index cf6e1a76b4d..9d573e044cb 100644
--- a/gcc/config/sh/sh.c
+++ b/gcc/config/sh/sh.c
@@ -10623,41 +10623,12 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
   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 ();
 
diff --git a/gcc/except.c b/gcc/except.c
index bc3b8c495a2..5a04fa68a8e 100644
--- a/gcc/except.c
+++ b/gcc/except.c
@@ -2117,7 +2117,10 @@ sjlj_build_landing_pads (void)
   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 @@ finish_eh_generation (void)
   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.  */
diff --git a/gcc/except.h b/gcc/except.h
index 18c36b01987..cf83af944a6 100644
--- a/gcc/except.h
+++ b/gcc/except.h
@@ -151,10 +151,6 @@ extern bool can_throw_external (const_rtx);
 /* 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);