2007-06-15 Kenneth Zadeck <zadeck@naturalbridge.com>

	* df.h (DF_FIRST_OPTIONAL_PROBLEM): Removed.
	(struct df_problem.free_blocks_on_set_blocks): New field.
	(struct dataflow.optional_p): New field.
	(df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
	(df_live_set_all_dirty): New function.
	* df-scan.c (df_scan_alloc): Initialize optional_p.
	(problem_SCAN): Initialize free_blocks_on_set_blocks.
	* df-core.c (df_set_blocks): Removed use of
	DF_FIRST_OPTIONAL_PROBLEM.  Now uses
	df_problem.free_blocks_on_set_blocks to determine which blocks are
	recycled.
	(df_remove_problem): Removed use of DF_FIRST_OPTIONAL_PROBLEM.
	(df_finish_pass): Removed use of DF_FIRST_OPTIONAL_PROBLEM.  Now
	uses dataflow.optional_p to determine if problem should be
	deleted.
	(rest_of_handle_df_initialize): Only start live problem if 
	-02 or above.
	(df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
	* df-problems.c (df_ru_alloc, df_rd_alloc, df_lr_alloc,
	df_live_alloc, df_urec_alloc, df_note_alloc): set optional_p.
	(problem_RU, problem_RD, problem_LR, problem_UREC, problem_CHAIN,
	problem_NOTE):  Initialize free_blocks_on_set_blocks.
	(df_lr_bb_local_compute): Recompute luids if df_live problem is
	not active.
	(df_live_set_all_dirty, df_note_alloc): New function.
	* regrename.c (merge_overlapping_regs): Change DF_LIVE_* to
	df_get_live_*.
	* sched_ebb.c (compute_jump_reg_dependencies): Ditto.
	* postreload.c (reload_combine): Ditto.
	* cse.c (cse_extended_basic_block): Ditto.
	* regmove.c (mark_flags_life_zones): Ditto.
	* rtlfactoring.c (split_blocks_after_seqs, split_pattern_seq,
	erase_matching_seqs): Ditto.
	* bt-load.c (compute_defs_uses_and_gen): Ditto.
	* integrate (allocate_initial_values): Ditto.
	* combine.c (reg_dead_at_p): Ditto.
	* resource.c (mark_target_live_regs): Ditto.
	* sched-rgn.c (check_live_1, update_live_1): Ditto.
	* config/sh/sh.c (find_r0_life_regions): Ditto.
	* global.c (rest_of_handle_global_alloc): Only add back df_live
	for -O > 1.
	* local-alloc.c (rest_of_handle_local_alloc): Only remove
	df_live for -O > 1.
	* ifcvt.c (dead_or_predicable): Change DF_LIVE_* to
	df_get_live_*.
	(if_convert): Make sure df_live is there at -O == 1.
	(pass_if_after_combine): Cleanup flags.
	* init-regs.c (initialize_uninitialized_regs): Make sure df_live
	is there at -O == 1.
	



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

21 files changed, 212 insertions, 143 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 8308ee683c7..2c19891b6dd 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,57 @@
+<<<<<<< .mine
+2007-06-15  Kenneth Zadeck <zadeck@naturalbridge.com>
+
+	* df.h (DF_FIRST_OPTIONAL_PROBLEM): Removed.
+	(struct df_problem.free_blocks_on_set_blocks): New field.
+	(struct dataflow.optional_p): New field.
+	(df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
+	(df_live_set_all_dirty): New function.
+	* df-scan.c (df_scan_alloc): Initialize optional_p.
+	(problem_SCAN): Initialize free_blocks_on_set_blocks.
+	* df-core.c (df_set_blocks): Removed use of
+	DF_FIRST_OPTIONAL_PROBLEM.  Now uses
+	df_problem.free_blocks_on_set_blocks to determine which blocks are
+	recycled.
+	(df_remove_problem): Removed use of DF_FIRST_OPTIONAL_PROBLEM.
+	(df_finish_pass): Removed use of DF_FIRST_OPTIONAL_PROBLEM.  Now
+	uses dataflow.optional_p to determine if problem should be
+	deleted.
+	(rest_of_handle_df_initialize): Only start live problem if 
+	-02 or above.
+	(df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
+	* df-problems.c (df_ru_alloc, df_rd_alloc, df_lr_alloc,
+	df_live_alloc, df_urec_alloc, df_note_alloc): set optional_p.
+	(problem_RU, problem_RD, problem_LR, problem_UREC, problem_CHAIN,
+	problem_NOTE):  Initialize free_blocks_on_set_blocks.
+	(df_lr_bb_local_compute): Recompute luids if df_live problem is
+	not active.
+	(df_live_set_all_dirty, df_note_alloc): New function.
+	* regrename.c (merge_overlapping_regs): Change DF_LIVE_* to
+	df_get_live_*.
+	* sched_ebb.c (compute_jump_reg_dependencies): Ditto.
+	* postreload.c (reload_combine): Ditto.
+	* cse.c (cse_extended_basic_block): Ditto.
+	* regmove.c (mark_flags_life_zones): Ditto.
+	* rtlfactoring.c (split_blocks_after_seqs, split_pattern_seq,
+	erase_matching_seqs): Ditto.
+	* bt-load.c (compute_defs_uses_and_gen): Ditto.
+	* integrate (allocate_initial_values): Ditto.
+	* combine.c (reg_dead_at_p): Ditto.
+	* resource.c (mark_target_live_regs): Ditto.
+	* sched-rgn.c (check_live_1, update_live_1): Ditto.
+	* config/sh/sh.c (find_r0_life_regions): Ditto.
+	* global.c (rest_of_handle_global_alloc): Only add back df_live
+	for -O > 1.
+	* local-alloc.c (rest_of_handle_local_alloc): Only remove
+	df_live for -O > 1.
+	* ifcvt.c (dead_or_predicable): Change DF_LIVE_* to
+	df_get_live_*.
+	(if_convert): Make sure df_live is there at -O == 1.
+	(pass_if_after_combine): Cleanup flags.
+	* init-regs.c (initialize_uninitialized_regs): Make sure df_live
+	is there at -O == 1.
+	
+=======
 2007-06-19  Seongbae Park  <seongbae.park@gmail.com>
 
 	* config/arm/arm.c (arm_get_frame_offsets): Set
@@ -44,6 +98,7 @@
 	* config/frv/frv.c (frv_ifcvt_modify_tests): Dataflow merge fix.
 	(frv_ifcvt_modify_insn): Likewise.
 
+>>>>>>> .r125856
 2007-06-19  Richard Guenther  <rguenther@suse.de>
 
 	* tree-ssa-structalias.c (handle_ptr_arith): Make sure to
@@ -719,6 +774,7 @@
 
        * df-scan.c (df_get_exit-block_use_set): Always add the stack pointer
        to the exit block use set.
+       (df_insn_delete, df_insn_rescan): Fixed spelling of "deferring". 
        * gcse.c (cpro_jump): Don't emit barrier in cfglayout mode.
        * config/sparc/sparc.c (sparc_check_64): Check df != NULL.
 
diff --git a/gcc/bt-load.c b/gcc/bt-load.c
index 91ea0e6d1e6..fbb413561f3 100644
--- a/gcc/bt-load.c
+++ b/gcc/bt-load.c
@@ -478,7 +478,7 @@ compute_defs_uses_and_gen (fibheap_t all_btr_defs, btr_def *def_array,
       CLEAR_HARD_REG_SET (info.btrs_written_in_block);
       for (reg = first_btr; reg <= last_btr; reg++)
 	if (TEST_HARD_REG_BIT (all_btrs, reg)
-	    && REGNO_REG_SET_P (DF_LIVE_IN (bb), reg))
+	    && REGNO_REG_SET_P (df_get_live_in (bb), reg))
 	  SET_HARD_REG_BIT (info.btrs_live_in_block, reg);
 
       for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb));
@@ -579,7 +579,7 @@ compute_defs_uses_and_gen (fibheap_t all_btr_defs, btr_def *def_array,
       COPY_HARD_REG_SET (btrs_live[i], info.btrs_live_in_block);
       COPY_HARD_REG_SET (btrs_written[i], info.btrs_written_in_block);
 
-      REG_SET_TO_HARD_REG_SET (btrs_live_at_end[i], DF_LIVE_OUT (bb));
+      REG_SET_TO_HARD_REG_SET (btrs_live_at_end[i], df_get_live_out (bb));
       /* If this block ends in a jump insn, add any uses or even clobbers
 	 of branch target registers that it might have.  */
       for (insn = BB_END (bb); insn != BB_HEAD (bb) && ! INSN_P (insn); )
diff --git a/gcc/combine.c b/gcc/combine.c
index 6fbf8168049..cb0d00f6f82 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -11835,7 +11835,7 @@ reg_dead_at_p (rtx reg, rtx insn)
     }
 
   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
-    if (REGNO_REG_SET_P (DF_LIVE_IN (block), i))
+    if (REGNO_REG_SET_P (df_get_live_in (block), i))
       return 0;
 
   return 1;
diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c
index 9d327847fe4..60520f7871c 100644
--- a/gcc/config/sh/sh.c
+++ b/gcc/config/sh/sh.c
@@ -9159,7 +9159,7 @@ find_r0_life_regions (basic_block b)
   int set;
   int death = 0;
 
-  if (REGNO_REG_SET_P (DF_LIVE_IN (b), R0_REG))
+  if (REGNO_REG_SET_P (df_get_live_in (b), R0_REG))
     {
       set = 1;
       live = 1;
diff --git a/gcc/cse.c b/gcc/cse.c
index 58055ddae06..431a4194bef 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -6001,8 +6001,8 @@ cse_extended_basic_block (struct cse_basic_block_data *ebb_data)
   qty_table = XNEWVEC (struct qty_table_elem, max_qty);
 
   new_basic_block ();
-  cse_ebb_live_in = DF_LIVE_IN (ebb_data->path[0].bb);
-  cse_ebb_live_out = DF_LIVE_OUT (ebb_data->path[path_size - 1].bb);
+  cse_ebb_live_in = df_get_live_in (ebb_data->path[0].bb);
+  cse_ebb_live_out = df_get_live_out (ebb_data->path[path_size - 1].bb);
   for (path_entry = 0; path_entry < path_size; path_entry++)
     {
       basic_block bb;
diff --git a/gcc/df-core.c b/gcc/df-core.c
index 67a4040d50e..deca8758530 100644
--- a/gcc/df-core.c
+++ b/gcc/df-core.c
@@ -506,15 +506,17 @@ df_set_blocks (bitmap blocks)
 	bitmap_print (dump_file, blocks, "setting blocks to analyze ", "\n");
       if (df->blocks_to_analyze)
 	{
+	  /* This block is called to change the focus from one subset
+	     to another.  */
 	  int p;
 	  bitmap diff = BITMAP_ALLOC (&df_bitmap_obstack);
 	  bitmap_and_compl (diff, df->blocks_to_analyze, blocks);
-	  for (p = df->num_problems_defined - 1; p >= DF_FIRST_OPTIONAL_PROBLEM ;p--)
+	  for (p = 0; p < df->num_problems_defined; p++)
 	    {
 	      struct dataflow *dflow = df->problems_in_order[p];
-	      if (dflow->problem->reset_fun)
+	      if (dflow->optional_p && dflow->problem->reset_fun)
 		dflow->problem->reset_fun (df->blocks_to_analyze);
-	      else if (dflow->problem->free_bb_fun)
+	      else if (dflow->problem->free_blocks_on_set_blocks)
 		{
 		  bitmap_iterator bi;
 		  unsigned int bb_index;
@@ -539,33 +541,31 @@ df_set_blocks (bitmap blocks)
 	}
       else
 	{
-	  /* If we have not actually run scanning before, do not try
-	     to clear anything.  */
-	  if (df_scan->problem_data)
+	  /* This block of code is executed to change the focus from
+	     the entire function to a subset.  */
+	  bitmap blocks_to_reset = NULL;
+	  int p;
+	  for (p = 0; p < df->num_problems_defined; p++)
 	    {
-	      bitmap blocks_to_reset = NULL;
-	      int p;
-	      for (p = df->num_problems_defined - 1; p >= DF_FIRST_OPTIONAL_PROBLEM ;p--)
+	      struct dataflow *dflow = df->problems_in_order[p];
+	      if (dflow->optional_p && dflow->problem->reset_fun)
 		{
-		  struct dataflow *dflow = df->problems_in_order[p];
-		  if (dflow->problem->reset_fun)
+		  if (!blocks_to_reset)
 		    {
-		      if (!blocks_to_reset)
+		      basic_block bb;
+		      blocks_to_reset =
+			BITMAP_ALLOC (&df_bitmap_obstack);
+		      FOR_ALL_BB(bb)
 			{
-			  basic_block bb;
-			  blocks_to_reset =
-			    BITMAP_ALLOC (&df_bitmap_obstack);
-			  FOR_ALL_BB(bb)
-			    {
-			      bitmap_set_bit (blocks_to_reset, bb->index); 
-			    }
+			  bitmap_set_bit (blocks_to_reset, bb->index); 
 			}
-		      dflow->problem->reset_fun (blocks_to_reset);
 		    }
+		  dflow->problem->reset_fun (blocks_to_reset);
 		}
-	      if (blocks_to_reset)
-		BITMAP_FREE (blocks_to_reset);
 	    }
+	  if (blocks_to_reset)
+	    BITMAP_FREE (blocks_to_reset);
+
 	  df->blocks_to_analyze = BITMAP_ALLOC (&df_bitmap_obstack);
 	}
       bitmap_copy (df->blocks_to_analyze, blocks);
@@ -573,8 +573,10 @@ df_set_blocks (bitmap blocks)
     }
   else
     {
+      /* This block is executed to reset the focus to the entire
+	 function.  */
       if (dump_file)
-	fprintf (dump_file, "clearing blocks to analyze\n");
+	fprintf (dump_file, "clearing blocks_to_analyze\n");
       if (df->blocks_to_analyze)
 	{
 	  BITMAP_FREE (df->blocks_to_analyze);
@@ -599,7 +601,6 @@ df_remove_problem (struct dataflow *dflow)
 {
   struct df_problem *problem;
   int i;
-  int start = 0;
 
   if (!dflow)
     return;
@@ -607,18 +608,13 @@ df_remove_problem (struct dataflow *dflow)
   problem = dflow->problem;
   gcc_assert (problem->remove_problem_fun);
 
-  /* Normally only optional problems are removed, but during global,
-     we remove ur and live and replace it with urec.  */
-  if (problem->id >= DF_FIRST_OPTIONAL_PROBLEM)
-    start = DF_FIRST_OPTIONAL_PROBLEM;
-
   /* Delete any problems that depended on this problem first.  */
-  for (i = start; i < df->num_problems_defined; i++)
+  for (i = 0; i < df->num_problems_defined; i++)
     if (df->problems_in_order[i]->problem->dependent_problem == problem)
       df_remove_problem (df->problems_in_order[i]);
 
   /* Now remove this problem.  */
-  for (i = start; i < df->num_problems_defined; i++)
+  for (i = 0; i < df->num_problems_defined; i++)
     if (df->problems_in_order[i] == dflow)
       {
 	int j;
@@ -658,16 +654,19 @@ df_finish_pass (void)
   saved_flags = df->changeable_flags;
 #endif
 
-  for (i = DF_FIRST_OPTIONAL_PROBLEM; i < df->num_problems_defined; i++)
+  for (i = 0; i < df->num_problems_defined; i++)
     {
       struct dataflow *dflow = df->problems_in_order[i];
       struct df_problem *problem = dflow->problem;
 
-      gcc_assert (problem->remove_problem_fun);
-      (problem->remove_problem_fun) ();
-      df->problems_in_order[i] = NULL;
-      df->problems_by_index[problem->id] = NULL;
-      removed++;
+      if (dflow->optional_p)
+	{
+	  gcc_assert (problem->remove_problem_fun);
+	  (problem->remove_problem_fun) ();
+	  df->problems_in_order[i] = NULL;
+	  df->problems_by_index[problem->id] = NULL;
+	  removed++;
+	}
     }
   df->num_problems_defined -= removed;
 
@@ -720,7 +719,7 @@ rest_of_handle_df_initialize (void)
 
   /* These three problems are permanent.  */
   df_lr_add_problem ();
-  if (optimize)
+  if (optimize > 1)
     df_live_add_problem ();
 
   df->postorder = XNEWVEC (int, last_basic_block);
@@ -1600,40 +1599,6 @@ df_set_clean_cfg (void)
 ----------------------------------------------------------------------------*/
 
 
-/* Return last use of REGNO within BB.  */
-
-struct df_ref *
-df_bb_regno_last_use_find (basic_block bb, unsigned int regno)
-{
-  rtx insn;
-  struct df_ref **use_rec;
-  unsigned int uid;
-
-  FOR_BB_INSNS_REVERSE (bb, insn)
-    {
-      if (!INSN_P (insn))
-	continue;
-
-      uid = INSN_UID (insn);
-      for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
-	{
-	  struct df_ref *use = *use_rec;
-	  if (DF_REF_REGNO (use) == regno)
-	    return use;
-	}
-
-      if (df->changeable_flags & DF_EQ_NOTES)
-	for (use_rec = DF_INSN_UID_EQ_USES (uid); *use_rec; use_rec++)
-	  {
-	    struct df_ref *use = *use_rec;
-	    if (DF_REF_REGNO (use) == regno)
-	      return use;
-	  }
-    }
-  return NULL;
-}
-
-
 /* Return first def of REGNO within BB.  */
 
 struct df_ref *
@@ -1686,26 +1651,6 @@ df_bb_regno_last_def_find (basic_block bb, unsigned int regno)
   return NULL;
 }
 
-/* Return true if INSN defines REGNO.  */
-
-bool
-df_insn_regno_def_p (rtx insn, unsigned int regno)
-{
-  unsigned int uid;
-  struct df_ref **def_rec;
-
-  uid = INSN_UID (insn);
-  for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
-    {
-      struct df_ref *def = *def_rec;
-      if (DF_REF_REGNO (def) == regno)
-	return true;
-    }
-  
-  return false;
-}
-
-
 /* Finds the reference corresponding to the definition of REG in INSN.
    DF is the dataflow object.  */
 
diff --git a/gcc/df-problems.c b/gcc/df-problems.c
index dc5270e935b..101b46f58e3 100644
--- a/gcc/df-problems.c
+++ b/gcc/df-problems.c
@@ -331,6 +331,7 @@ df_ru_alloc (bitmap all_blocks)
 	  bb_info->out = BITMAP_ALLOC (&problem_data->ru_bitmaps);
 	}
     }
+  df_ru->optional_p = true;
 }
 
 
@@ -711,7 +712,8 @@ static struct df_problem problem_RU =
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verfiy end.  */
   NULL,                       /* Dependent problem.  */
-  TV_DF_RU                    /* Timing variable.  */ 
+  TV_DF_RU,                   /* Timing variable.  */
+  true                        /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -841,6 +843,7 @@ df_rd_alloc (bitmap all_blocks)
 	  bb_info->out = BITMAP_ALLOC (&problem_data->rd_bitmaps);
 	}
     }
+  df_rd->optional_p = true;
 }
 
 
@@ -1207,7 +1210,8 @@ static struct df_problem problem_RD =
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verfiy end.  */
   NULL,                       /* Dependent problem.  */
-  TV_DF_RD                    /* Timing variable.  */ 
+  TV_DF_RD,                   /* Timing variable.  */ 
+  true                        /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -1320,6 +1324,8 @@ df_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
           bb_info->ause = NULL;
 	}
     }
+
+  df_lr->optional_p = false;
 }
 
 
@@ -1478,6 +1484,13 @@ df_lr_bb_local_compute (unsigned int bb_index)
 	}
     }
 #endif
+
+  /* If the df_live problem is not defined, such as at -O0 and -O1, we
+     still need to keep the luids up to date.  This is normally done
+     in the df_live problem since this problem has a forwards
+     scan.  */
+  if (!df_live)
+    df_recompute_luids (bb);
 }
 
 
@@ -1818,7 +1831,8 @@ static struct df_problem problem_LR =
   df_lr_verify_solution_start,/* Incremental solution verify start.  */
   df_lr_verify_solution_end,  /* Incremental solution verify end.  */
   NULL,                       /* Dependent problem.  */
-  TV_DF_LR                    /* Timing variable.  */ 
+  TV_DF_LR,                   /* Timing variable.  */ 
+  false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -2016,6 +2030,7 @@ df_live_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
 	  bb_info->out = BITMAP_ALLOC (NULL);
 	}
     }
+  df_live->optional_p = (optimize <= 1);
 }
 
 
@@ -2368,7 +2383,8 @@ static struct df_problem problem_LIVE =
   df_live_verify_solution_start,/* Incremental solution verify start.  */
   df_live_verify_solution_end,  /* Incremental solution verify end.  */
   &problem_LR,                  /* Dependent problem.  */
-  TV_DF_LIVE                    /* Timing variable.  */ 
+  TV_DF_LIVE,                   /* Timing variable.  */
+  false                         /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -2386,6 +2402,19 @@ df_live_add_problem (void)
 }
 
 
+/* Set all of the blocks as dirty.  This needs to be done if this
+   problem is added after all of the insns have been scanned.  */
+
+void
+df_live_set_all_dirty (void)
+{
+  basic_block bb;
+  FOR_ALL_BB (bb)
+    bitmap_set_bit (df_live->out_of_date_transfer_functions, 
+		    bb->index);
+}
+
+
 /* Verify that all of the lr related info is consistent and
    correct.  */
 
@@ -2555,6 +2584,7 @@ df_urec_alloc (bitmap all_blocks)
 	  bb_info->earlyclobber = BITMAP_ALLOC (NULL);
 	}
     }
+  df_urec->optional_p = true;
 }
 
 
@@ -3041,7 +3071,8 @@ static struct df_problem problem_UREC =
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verfiy end.  */
   &problem_LR,                /* Dependent problem.  */
-  TV_DF_UREC                  /* Timing variable.  */ 
+  TV_DF_UREC,                 /* Timing variable.  */ 
+  false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -3213,6 +3244,7 @@ df_chain_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
   df_chain_remove_problem ();
   df_chain->block_pool = create_alloc_pool ("df_chain_block pool", 
 					 sizeof (struct df_link), 50);
+  df_chain->optional_p = true;
 }
 
 
@@ -3520,7 +3552,8 @@ static struct df_problem problem_CHAIN =
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verfiy end.  */
   &problem_RD,                /* Dependent problem.  */
-  TV_DF_CHAIN                 /* Timing variable.  */ 
+  TV_DF_CHAIN,                /* Timing variable.  */
+  false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
@@ -3543,6 +3576,12 @@ df_chain_add_problem (enum df_chain_flags chain_flags)
    This pass computes REG_DEAD and REG_UNUSED notes.
    ----------------------------------------------------------------------------*/
 
+static void 
+df_note_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
+{
+  df_note->optional_p = true;
+}
+
 #ifdef REG_DEAD_DEBUGGING
 static void 
 df_print_note (const char *prefix, rtx insn, rtx note)
@@ -4077,7 +4116,7 @@ static struct df_problem problem_NOTE =
 {
   DF_NOTE,                    /* Problem id.  */
   DF_NONE,                    /* Direction.  */
-  NULL,                       /* Allocate the problem specific data.  */
+  df_note_alloc,              /* Allocate the problem specific data.  */
   NULL,                       /* Reset global information.  */
   NULL,                       /* Free basic block info.  */
   df_note_compute,            /* Local compute function.  */
@@ -4099,7 +4138,8 @@ static struct df_problem problem_NOTE =
      but it will produce information if built one of uninitialized
      register problems (UR, UREC) is also run.  */
   &problem_LR,                /* Dependent problem.  */
-  TV_DF_NOTE                  /* Timing variable.  */ 
+  TV_DF_NOTE,                 /* Timing variable.  */
+  false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index 49d6df8ca15..fff621f0261 100644
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -341,6 +341,7 @@ df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
   df->insns_to_delete = BITMAP_ALLOC (&problem_data->insn_bitmaps);
   df->insns_to_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
   df->insns_to_notes_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
+  df_scan->optional_p = false;
 }
 
 
@@ -434,7 +435,8 @@ static struct df_problem problem_SCAN =
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verfiy end.  */
   NULL,                       /* Dependent problem.  */
-  TV_DF_SCAN                  /* Timing variable.  */
+  TV_DF_SCAN,                 /* Timing variable.  */
+  false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
 
 
diff --git a/gcc/df.h b/gcc/df.h
index 9a3345c7ce0..5c510eec6f9 100644
--- a/gcc/df.h
+++ b/gcc/df.h
@@ -52,7 +52,6 @@ struct df_link;
 #define DF_NOTE  7      /* REG_DEF and REG_UNUSED notes. */
 
 #define DF_LAST_PROBLEM_PLUS1 (DF_NOTE + 1)
-#define DF_FIRST_OPTIONAL_PROBLEM DF_RU
 
 /* Dataflow direction.  */
 enum df_flow_dir
@@ -249,8 +248,13 @@ struct df_problem {
   df_verify_solution_start verify_start_fun;
   df_verify_solution_end verify_end_fun;
   struct df_problem *dependent_problem;
+
   /* The timevar id associated with this pass.  */
   unsigned int tv_id;
+
+  /* True if the df_set_blocks should null out the basic block info if
+     this block drops out of df->blocks_to_analyze.  */
+  bool free_blocks_on_set_blocks;
 };
 
 
@@ -293,6 +297,11 @@ struct dataflow
      solutions.  Note that this bit is always true for all problems except 
      lr and live.  */
   bool solutions_dirty;
+
+  /* If true, this pass is deleted by df_finish_pass.  This is never
+     true for DF_SCAN and DF_LR.  It is true for DF_LIVE if optimize >
+     1.  It is always true for the other problems.  */
+  bool optional_p;
 };
 
 
@@ -837,10 +846,8 @@ extern void df_verify (void);
 #ifdef DF_DEBUG_CFG
 extern void df_check_cfg_clean (void);
 #endif
-extern struct df_ref *df_bb_regno_last_use_find (basic_block, unsigned int);
 extern struct df_ref *df_bb_regno_first_def_find (basic_block, unsigned int);
 extern struct df_ref *df_bb_regno_last_def_find (basic_block, unsigned int);
-extern bool df_insn_regno_def_p (rtx, unsigned int);
 extern struct df_ref *df_find_def (rtx, rtx);
 extern bool df_reg_defined (rtx, rtx);
 extern struct df_ref *df_find_use (rtx, rtx);
@@ -882,6 +889,7 @@ extern void df_lr_add_problem (void);
 extern void df_lr_verify_transfer_functions (void);
 extern void df_live_verify_transfer_functions (void);
 extern void df_live_add_problem (void);
+extern void df_live_set_all_dirty (void);
 extern void df_urec_add_problem (void);
 extern void df_chain_add_problem (enum df_chain_flags);
 extern void df_note_add_problem (void);
diff --git a/gcc/global.c b/gcc/global.c
index c60c57df64e..62b7b6273e3 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -2080,7 +2080,7 @@ rest_of_handle_global_alloc (void)
      going to help here because it does not touch the artificial uses
      and defs.  */
   df_finish_pass ();
-  if (optimize)
+  if (optimize > 1)
     df_live_add_problem ();
   df_scan_alloc (NULL);
   df_scan_blocks ();
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index e5d88970be0..dd7764b921f 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -3836,7 +3836,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
       
       /* The loop below takes the set of live registers 
          after JUMP, and calculates the live set before EARLIEST. */
-      bitmap_copy (test_live, DF_LIVE_IN (other_bb));
+      bitmap_copy (test_live, df_get_live_in (other_bb));
       df_simulate_artificial_refs_at_end (test_bb, test_live);
       for (insn = jump; ; insn = prev)
 	{
@@ -3858,7 +3858,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
 
       if (bitmap_intersect_p (test_set, merge_set)
 	  || bitmap_intersect_p (test_live, merge_set)
-	  || bitmap_intersect_p (test_set, DF_LIVE_IN (merge_bb)))
+	  || bitmap_intersect_p (test_set, df_get_live_in (merge_bb)))
 	fail = 1;
 
       BITMAP_FREE (merge_set);
@@ -3958,6 +3958,12 @@ if_convert (bool recompute_dominance)
   basic_block bb;
   int pass;
 
+  if (optimize == 1)
+    {
+      df_live_add_problem ();
+      df_live_set_all_dirty ();
+    }
+
   num_possible_if_blocks = 0;
   num_updated_if_blocks = 0;
   num_true_changes = 0;
@@ -4039,6 +4045,9 @@ if_convert (bool recompute_dominance)
 	       num_true_changes);
     }
 
+  if (optimize == 1)
+    df_remove_problem (df_live);
+
 #ifdef ENABLE_CHECKING
   verify_flow_info ();
 #endif
@@ -4125,14 +4134,13 @@ struct tree_opt_pass pass_if_after_combine =
 static bool
 gate_handle_if_after_reload (void)
 {
-  return (optimize > 0);
+  return (optimize > 0 && flag_if_conversion2);
 }
 
 static unsigned int
 rest_of_handle_if_after_reload (void)
 {
-  if (flag_if_conversion2)
-    if_convert (true);
+  if_convert (true);
   return 0;
 }
 
diff --git a/gcc/init-regs.c b/gcc/init-regs.c
index adde3fa2cd7..7e4d0565122 100644
--- a/gcc/init-regs.c
+++ b/gcc/init-regs.c
@@ -53,6 +53,12 @@ initialize_uninitialized_regs (void)
   basic_block bb;
   bitmap already_genned = BITMAP_ALLOC (NULL);
 
+  if (optimize == 1)
+    {
+      df_live_add_problem ();
+      df_live_set_all_dirty ();
+    }
+
   df_analyze ();
 
   FOR_EACH_BB (bb)
@@ -111,6 +117,9 @@ initialize_uninitialized_regs (void)
 	}
     }
 
+  if (optimize == 1)
+    df_remove_problem (df_live);
+
   BITMAP_FREE (already_genned);
 }
 
diff --git a/gcc/integrate.c b/gcc/integrate.c
index 827afb7fe51..fb893ddb00e 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -352,10 +352,10 @@ allocate_initial_values (rtx *reg_equiv_memory_loc)
 		  /* Update global register liveness information.  */
 		  FOR_EACH_BB (bb)
 		    {
-		      if (REGNO_REG_SET_P(DF_LIVE_IN (bb), regno))
-			SET_REGNO_REG_SET (DF_LIVE_IN (bb), new_regno);
-		      if (REGNO_REG_SET_P(DF_LIVE_OUT (bb), regno))
-			SET_REGNO_REG_SET (DF_LIVE_OUT (bb), new_regno);
+		      if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
+			SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
+		      if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
+			SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
 		    }
 		}
 	    }
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index 93bdbfac1c3..59ee52fd3c0 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -2509,13 +2509,13 @@ rest_of_handle_local_alloc (void)
   int max_regno = max_reg_num ();
 
   df_note_add_problem ();
+
+  if (optimize > 1)
+    df_remove_problem (df_live);
+  /* Create a new version of df that has the special version of UR if
+     we are doing optimization.  */
   if (optimize)
-    {
-      /* Create a new version of df that has the special version of UR
-	 if we are doing optimization.  */
-      df_remove_problem (df_live);
-      df_urec_add_problem ();
-    }
+    df_urec_add_problem ();
   df_analyze ();
   regstat_init_n_sets_and_refs ();
   regstat_compute_ri ();
diff --git a/gcc/postreload.c b/gcc/postreload.c
index 3182ac0b8e9..3894efaec8f 100644
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -743,9 +743,10 @@ reload_combine (void)
       if (LABEL_P (insn))
 	{
 	  HARD_REG_SET live;
+	  bitmap live_in = df_get_live_in (bb);
 
-	  REG_SET_TO_HARD_REG_SET (live, DF_LIVE_IN (bb));
-	  compute_use_by_pseudos (&live, DF_LIVE_IN (bb));
+	  REG_SET_TO_HARD_REG_SET (live, live_in);
+	  compute_use_by_pseudos (&live, live_in);
 	  COPY_HARD_REG_SET (LABEL_LIVE (insn), live);
 	  IOR_HARD_REG_SET (ever_live_at_start, live);
 	}
diff --git a/gcc/regmove.c b/gcc/regmove.c
index c54879bc3a7..067940f4b7c 100644
--- a/gcc/regmove.c
+++ b/gcc/regmove.c
@@ -325,7 +325,7 @@ mark_flags_life_zones (rtx flags)
       {
 	int i;
 	for (i = 0; i < flags_nregs; ++i)
-	  live |= REGNO_REG_SET_P (DF_LIVE_IN (block), flags_regno + i);
+	  live |= REGNO_REG_SET_P (df_get_live_in (block), flags_regno + i);
       }
 #endif
 
diff --git a/gcc/regrename.c b/gcc/regrename.c
index 7026ef3b47d..8fdc74e92ab 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -139,7 +139,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
   rtx insn;
   HARD_REG_SET live;
 
-  REG_SET_TO_HARD_REG_SET (live, DF_LIVE_IN (b));
+  REG_SET_TO_HARD_REG_SET (live, df_get_live_in (b));
   insn = BB_HEAD (b);
   while (t)
     {
diff --git a/gcc/resource.c b/gcc/resource.c
index c2b08495d0a..6f9456f0383 100644
--- a/gcc/resource.c
+++ b/gcc/resource.c
@@ -957,7 +957,7 @@ mark_target_live_regs (rtx insns, rtx target, struct resources *res)
      TARGET.  Otherwise, we must assume everything is live.  */
   if (b != -1)
     {
-      regset regs_live = DF_LIVE_IN (BASIC_BLOCK (b));
+      regset regs_live = df_get_live_in (BASIC_BLOCK (b));
       rtx start_insn, stop_insn;
       reg_set_iterator rsi;
 
diff --git a/gcc/rtl-factoring.c b/gcc/rtl-factoring.c
index 8ab5e8bd3dd..6e37df7bced 100644
--- a/gcc/rtl-factoring.c
+++ b/gcc/rtl-factoring.c
@@ -978,8 +978,8 @@ split_blocks_after_seqs (void)
       for (mseq = sb->matching_seqs; mseq; mseq = mseq->next_matching_seq)
         {
           block_label_after (mseq->insn);
-          IOR_REG_SET (DF_LIVE_OUT (BLOCK_FOR_INSN (pattern_seqs->insn)),
-                       DF_LIVE_OUT (BLOCK_FOR_INSN (mseq->insn)));
+          IOR_REG_SET (df_get_live_out (BLOCK_FOR_INSN (pattern_seqs->insn)),
+                       df_get_live_out (BLOCK_FOR_INSN (mseq->insn)));
         }
     }
 }
@@ -1033,7 +1033,7 @@ split_pattern_seq (void)
                               gen_symbol_ref_rtx_for_label
                               (retlabel)), BB_END (bb));
   /* Update liveness info.  */
-  SET_REGNO_REG_SET (DF_LIVE_OUT (bb),
+  SET_REGNO_REG_SET (df_get_live_out (bb),
                      REGNO (pattern_seqs->link_reg));
 }
 
@@ -1085,12 +1085,12 @@ erase_matching_seqs (void)
           BB_END (bb) = callinsn;
 
           /* Maintain control flow and liveness information.  */
-          SET_REGNO_REG_SET (DF_LIVE_OUT (bb),
+          SET_REGNO_REG_SET (df_get_live_out (bb),
                              REGNO (pattern_seqs->link_reg));
           emit_barrier_after (BB_END (bb));
           make_single_succ_edge (bb, BLOCK_FOR_INSN (sb->label), 0);
-          IOR_REG_SET (DF_LIVE_OUT (bb),
-		       DF_LIVE_IN (BLOCK_FOR_INSN (sb->label)));
+          IOR_REG_SET (df_get_live_out (bb),
+		       df_get_live_in (BLOCK_FOR_INSN (sb->label)));
 
           make_edge (BLOCK_FOR_INSN (seq_blocks->label),
                      BLOCK_FOR_INSN (retlabel), EDGE_ABNORMAL);
diff --git a/gcc/sched-ebb.c b/gcc/sched-ebb.c
index dbece7d80e3..b03655d889f 100644
--- a/gcc/sched-ebb.c
+++ b/gcc/sched-ebb.c
@@ -252,9 +252,9 @@ compute_jump_reg_dependencies (rtx insn, regset cond_set, regset used,
 	 it may guard the fallthrough block from using a value that has
 	 conditionally overwritten that of the main codepath.  So we
 	 consider that it restores the value of the main codepath.  */
-      bitmap_and (set, DF_LIVE_IN (e->dest), cond_set);
+      bitmap_and (set, df_get_live_in (e->dest), cond_set);
     else
-      bitmap_ior_into (used, DF_LIVE_IN (e->dest));
+      bitmap_ior_into (used, df_get_live_in (e->dest));
 }
 
 /* Used in schedule_insns to initialize current_sched_info for scheduling
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index aafb8121ea0..0bb69ee4cdc 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -1551,7 +1551,7 @@ check_live_1 (int src, rtx x)
 		  gcc_assert (!t || (CONTAINING_RGN (b->index)
 				     != CONTAINING_RGN (BB_TO_BLOCK (src))));
 
-		  if (t || REGNO_REG_SET_P (DF_LIVE_IN (b), regno + j))
+		  if (t || REGNO_REG_SET_P (df_get_live_in (b), regno + j))
 		    return 0;
 		}
 	    }
@@ -1567,7 +1567,7 @@ check_live_1 (int src, rtx x)
 	      gcc_assert (!t || (CONTAINING_RGN (b->index)
 				 != CONTAINING_RGN (BB_TO_BLOCK (src))));
 
-	      if (t || REGNO_REG_SET_P (DF_LIVE_IN (b), regno))
+	      if (t || REGNO_REG_SET_P (df_get_live_in (b), regno))
 		return 0;
 	    }
 	}
@@ -1624,7 +1624,7 @@ update_live_1 (int src, rtx x)
 		{
 		  basic_block b = candidate_table[src].update_bbs.first_member[i];
 
-		  SET_REGNO_REG_SET (DF_LIVE_IN (b), regno + j);
+		  SET_REGNO_REG_SET (df_get_live_in (b), regno + j);
 		}
 	    }
 	}
@@ -1634,7 +1634,7 @@ update_live_1 (int src, rtx x)
 	    {
 	      basic_block b = candidate_table[src].update_bbs.first_member[i];
 
-	      SET_REGNO_REG_SET (DF_LIVE_IN (b), regno);
+	      SET_REGNO_REG_SET (df_get_live_in (b), regno);
 	    }
 	}
     }