use operator == / != instead of bitmap_equal_p

10 files changed, 35 insertions, 32 deletions

diff --git a/gcc/bitmap.c b/gcc/bitmap.c
index c763f446373..f647fca77a4 100644
--- a/gcc/bitmap.c
+++ b/gcc/bitmap.c
@@ -1783,13 +1783,13 @@ bitmap_xor_into (bitmap a, const_bitmap b)
    occurs in practice.  */
 
 bool
-bitmap_equal_p (const_bitmap a, const_bitmap b)
+bitmap_head::operator== (const bitmap_head &other) const
 {
   const bitmap_element *a_elt;
   const bitmap_element *b_elt;
   unsigned ix;
 
-  for (a_elt = a->first, b_elt = b->first;
+  for (a_elt = first, b_elt = other.first;
        a_elt && b_elt;
        a_elt = a_elt->next, b_elt = b_elt->next)
     {
@@ -1877,7 +1877,7 @@ bitmap_ior_and_compl (bitmap dst, const_bitmap a, const_bitmap b, const_bitmap k
   /* Special cases.  We don't bother checking for bitmap_equal_p (b, kill).  */
   if (b == kill || b->is_empty ())
     {
-      changed = !bitmap_equal_p (dst, a);
+      changed = *dst != *a;
       if (changed)
 	bitmap_copy (dst, a);
       return changed;
diff --git a/gcc/bitmap.h b/gcc/bitmap.h
index 92ad5338f9d..2f0112e80cf 100644
--- a/gcc/bitmap.h
+++ b/gcc/bitmap.h
@@ -225,6 +225,13 @@ struct GTY(()) bitmap_head {
   /* Return true if a register is set in a register set.  */
   bool bit (int) const;
 
+/* True if two bitmaps are identical.  */
+  bool operator== (const bitmap_head &) const;
+  bool operator!= (const bitmap_head &other) const
+    {
+      return !(*this == other);
+    }
+
   void swap (bitmap_head *);
 
   /* Compute bitmap hash (for purposes of hashing etc.)  */
@@ -247,9 +254,6 @@ struct GTY(()) bitmap_head {
 };
 
 
-/* True if two bitmaps are identical.  */
-extern bool bitmap_equal_p (const_bitmap, const_bitmap);
-
 /* True if the complement of the second intersects the first (their
    AND_COMPL is non-empty).  */
 extern bool bitmap_intersect_compl_p (const_bitmap, const_bitmap);
diff --git a/gcc/dce.c b/gcc/dce.c
index 981c2163506..c17846d9cf2 100644
--- a/gcc/dce.c
+++ b/gcc/dce.c
@@ -914,7 +914,7 @@ word_dce_process_block (basic_block bb, bool redo_out,
 	  }
       }
 
-  block_changed = !bitmap_equal_p (&local_live, DF_WORD_LR_IN (bb));
+  block_changed = local_live != *DF_WORD_LR_IN (bb);
   if (block_changed)
     bitmap_copy (DF_WORD_LR_IN (bb), &local_live);
 
@@ -1010,7 +1010,7 @@ dce_process_block (basic_block bb, bool redo_out, bitmap au,
   dead_debug_local_finish (&debug, NULL);
   df_simulate_finalize_backwards (bb, &local_live);
 
-  block_changed = !bitmap_equal_p (&local_live, DF_LR_IN (bb));
+  block_changed = local_live != *DF_LR_IN (bb);
   if (block_changed)
     bitmap_copy (DF_LR_IN (bb), &local_live);
 
diff --git a/gcc/df-problems.c b/gcc/df-problems.c
index a6643480e46..00ee28eed09 100644
--- a/gcc/df-problems.c
+++ b/gcc/df-problems.c
@@ -523,7 +523,7 @@ df_rd_transfer_function (int bb_index)
 	}
       bitmap_and_compl_into (&tmp, kill);
       bitmap_ior_into (&tmp, gen);
-      changed = !bitmap_equal_p (&tmp, out);
+      changed = tmp != *out;
       if (changed)
 	{
 	  bitmap_clear (out);
@@ -1192,8 +1192,8 @@ df_lr_verify_solution_end (void)
   else
     FOR_ALL_BB_FN (bb, cfun)
       {
-	if ((!bitmap_equal_p (&problem_data->in[bb->index], DF_LR_IN (bb)))
-	    || (!bitmap_equal_p (&problem_data->out[bb->index], DF_LR_OUT (bb))))
+	if (problem_data->in[bb->index] != *DF_LR_IN (bb)
+	    || problem_data->out[bb->index] != *DF_LR_OUT (bb))
 	  {
 	    /*df_dump (stderr);*/
 	    gcc_unreachable ();
@@ -1290,8 +1290,8 @@ df_lr_verify_transfer_functions (void)
 	      saved_use.swap (&bb_info->use);
 
 	      df_lr_bb_local_compute (bb->index);
-	      gcc_assert (bitmap_equal_p (&saved_def, &bb_info->def));
-	      gcc_assert (bitmap_equal_p (&saved_use, &bb_info->use));
+	      gcc_assert (saved_def == bb_info->def);
+	      gcc_assert (saved_use == bb_info->use);
 	    }
 	}
       else
@@ -1710,8 +1710,8 @@ df_live_verify_solution_end (void)
 
   FOR_ALL_BB_FN (bb, cfun)
     {
-      if ((!bitmap_equal_p (&problem_data->in[bb->index], DF_LIVE_IN (bb)))
-	  || (!bitmap_equal_p (&problem_data->out[bb->index], DF_LIVE_OUT (bb))))
+      if (problem_data->in[bb->index] != *DF_LIVE_IN (bb)
+	  || problem_data->out[bb->index] != *DF_LIVE_OUT (bb))
 	{
 	  /*df_dump (stderr);*/
 	  gcc_unreachable ();
@@ -1822,8 +1822,8 @@ df_live_verify_transfer_functions (void)
 	      saved_kill.swap (&bb_info->kill);
 
 	      df_live_bb_local_compute (bb->index);
-	      gcc_assert (bitmap_equal_p (&saved_gen, &bb_info->gen));
-	      gcc_assert (bitmap_equal_p (&saved_kill, &bb_info->kill));
+	      gcc_assert (saved_gen == bb_info->gen);
+	      gcc_assert (saved_kill == bb_info->kill);
 	    }
 	}
       else
diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index 80bb1db1d35..bf1bac78934 100644
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -3902,7 +3902,7 @@ df_update_entry_block_defs (void)
   df_get_entry_block_def_set (&refs);
   if (df->entry_block_defs)
     {
-      if (!bitmap_equal_p (df->entry_block_defs, &refs))
+      if (*df->entry_block_defs != refs)
 	{
 	  struct df_scan_bb_info *bb_info = df_scan_get_bb_info (ENTRY_BLOCK);
 	  df_ref_chain_delete_du_chain (bb_info->artificial_defs);
@@ -4073,7 +4073,7 @@ df_update_exit_block_uses (void)
   df_get_exit_block_use_set (&refs);
   if (df->exit_block_uses)
     {
-      if (!bitmap_equal_p (df->exit_block_uses, &refs))
+      if (*df->exit_block_uses != refs)
 	{
 	  struct df_scan_bb_info *bb_info = df_scan_get_bb_info (EXIT_BLOCK);
 	  df_ref_chain_delete_du_chain (bb_info->artificial_uses);
@@ -4451,7 +4451,7 @@ df_entry_block_bitmap_verify (bool abort_if_fail)
 
   df_get_entry_block_def_set (&entry_block_defs);
 
-  is_eq = bitmap_equal_p (&entry_block_defs, df->entry_block_defs);
+  is_eq = entry_block_defs == *df->entry_block_defs;
 
   if (!is_eq && abort_if_fail)
     {
@@ -4477,7 +4477,7 @@ df_exit_block_bitmap_verify (bool abort_if_fail)
 
   df_get_exit_block_use_set (&exit_block_uses);
 
-  is_eq = bitmap_equal_p (&exit_block_uses, df->exit_block_uses);
+  is_eq = exit_block_uses == *df->exit_block_uses;
 
   if (!is_eq && abort_if_fail)
     {
@@ -4530,10 +4530,9 @@ df_scan_verify (void)
 		   &regular_block_artificial_uses);
 
   /* Check artificial_uses bitmaps didn't change. */
-  gcc_assert (bitmap_equal_p (&regular_block_artificial_uses,
-			      &df->regular_block_artificial_uses));
-  gcc_assert (bitmap_equal_p (&eh_block_artificial_uses,
-			      &df->eh_block_artificial_uses));
+  gcc_assert (regular_block_artificial_uses ==
+	      df->regular_block_artificial_uses);
+  gcc_assert (eh_block_artificial_uses == df->eh_block_artificial_uses);
 
   /* Verify entry block and exit block. These only verify the bitmaps,
      the refs are verified in df_bb_verify.  */
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index e1e04922472..4f151a35d7b 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -302,7 +302,7 @@ union_static_var_sets (bitmap &x, bitmap y)
 	     turns out to be an overall win to check this here for
 	     an LTO bootstrap of GCC itself.  Liberally extrapoliate
 	     that result to be applicable to all cases.  */
-	  if (bitmap_equal_p (x, all_module_statics))
+	  if (*x == *all_module_statics)
 	    {
 	      BITMAP_FREE (x);
 	      x = all_module_statics;
@@ -323,7 +323,7 @@ intersect_static_var_sets (bitmap &x, bitmap y)
       bitmap_and_into (x, y);
       /* As with union_static_var_sets, reducing to the maximum
 	 set as early as possible is an overall win.  */
-      if (bitmap_equal_p (x, all_module_statics))
+      if (*x == *all_module_statics)
 	{
 	  BITMAP_FREE (x);
 	  x = all_module_statics;
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 04e1c225df0..2c150618b89 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -871,7 +871,7 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
 static bool
 bitmap_set_equal (bitmap_set_t a, bitmap_set_t b)
 {
-  return bitmap_equal_p (&a->values, &b->values);
+  return a->values == b->values;
 }
 
 /* Replace an instance of EXPR's VALUE with EXPR in SET if it exists,
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 4342cfe0c81..231d492e81a 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -1913,7 +1913,7 @@ inline bool
 equiv_class_hasher::equal (const value_type *eql1, const compare_type *eql2)
 {
   return (eql1->hashcode == eql2->hashcode
-	  && bitmap_equal_p (eql1->labels, eql2->labels));
+	  && *eql1->labels == *eql2->labels);
 }
 
 /* A hashtable for mapping a bitmap of labels->pointer equivalence
@@ -5945,7 +5945,7 @@ shared_bitmap_hasher::hash (const value_type *bi)
 inline bool
 shared_bitmap_hasher::equal (const value_type *sbi1, const compare_type *sbi2)
 {
-  return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars);
+  return *sbi1->pt_vars == *sbi2->pt_vars;
 }
 
 /* Shared_bitmap hashtable.  */
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index 800acdb6abe..e911ceca975 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -558,7 +558,7 @@ same_succ_def::equal (const value_type *e1, const compare_type *e2)
   if (e1->succ_flags.length () != e2->succ_flags.length ())
     return 0;
 
-  if (!bitmap_equal_p (e1->succs, e2->succs))
+  if (*e1->succs != *e2->succs)
     return 0;
 
   if (!inverse_flags (e1, e2))
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 3aaa00613ed..95bed85146a 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -804,7 +804,7 @@ vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2)
 	  || ((!b1 || b1->is_empty ())
 	      && (!b2 || b2->is_empty ()))
 	  || (b1 && b2
-	      && bitmap_equal_p (b1, b2)));
+	      && *b1 == *b2));
 }
 
 /* Update the value range and equivalence set for variable VAR to