From: Richard Sandiford <rdsandiford@googlemail.com>
Date: Mon, 30 Sep 2013 20:35:40 +0000 (+0000)
Subject: basic-block.h (edge_list): Prefix member names with "m_".
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=65d3284bfe05bd65415f9caf9f535e8bb745bdd1;p=gcc.git

basic-block.h (edge_list): Prefix member names with "m_".

gcc/
	* basic-block.h (edge_list): Prefix member names with "m_".
	* context.h (context): Likewise.
	* domwalk.h (dom_walker): Likewise.
	* gengtype-state.c (s_expr_writer, state_writer): Likewise.
	* graphite-sese-to-poly.c (sese_dom_walker): Likewise.
	* hash-table.h (hash_table): Likewise.
	* machmode.h (bit_field_mode_iterator): Likewise.
	* pass_manager.h (pass_list): Likewise.
	* tree-into-ssa.c (mark_def_dom_walker): Likewise.
	* tree-pass.h (pass_data): Likewise.
	* tree-ssa-dom.c (dom_opt_dom_walker): Likewise.
	* tree-ssa-phiopt.c (nontrapping_dom_walker): Likewise,
	* tree-ssa-uncprop.c (uncprop_dom_walker): Likewise.
	* asan.c (pass_data_asan): Update accordingly.
	* cfganal.c (control_dependences::find_control_dependence): Likewise.
	(control_dependences::control_dependences): Likewise.
	(control_dependences::~control_dependences): Likewise.
	(control_dependences::~control_dependences): Likewise.
	(control_dependences::get_edges_dependent_on): Likewise.
	* cgraphbuild.c (pass_data_rebuild_cgraph_edges::clone): Likewise.
	(pass_data_remove_cgraph_callee_edges::clone): Likewise.
	* context.c (gcc::context::context): Likewise.
	* cprop.c (pass_rtl_cprop::clone): Likewise.
	* domwalk.c (dom_walker::walk): Likewise.
	* ipa-inline-analysis.c (pass_inline_parameters::clone): Likewise.
	* ipa-pure-const.c (pass_local_pure_const::clone): Likewise.
	* mode-switching.c (pass_mode_switching::clone): Likewise.
	* passes.c (opt_pass::opt_pass): Likewise.
	(pass_manager::pass_manager): Likewise.
	* predict.c (pass_strip_predict_hints::clone): Likewise.
	* recog.c (pass_data pass_data_peephole2::clone): Likewise.
	(pass_split_all_insns::clone): Likewise.
	* stor-layout.c (bit_field_mode_iterator::bit_field_mode_iterator):
	Likewise.
	(bit_field_mode_iterator::next_mode): Likewise.
	(bit_field_mode_iterator::prefer_smaller_modes): Likewise.
	* tree-cfg.c (pass_split_crit_edges::clone): Likewise.
	* tree-cfgcleanup.c (pass_merge_phi::clone): Likewise.
	* tree-complex.c (pass_lower_complex::clone): Likewise.
	* tree-eh.c (pass_cleanup_eh::clone): Likewise.
	* tree-object-size.c (pass_object_sizes::clone): Likewise.
	* tree-optimize.c (pass_fixup_cfg::clone): Likewise.
	* tree-ssa-ccp.c (pass_data_ccp::clone): Likewise.
	(pass_fold_builtins::clone): Likewise.
	* tree-ssa-copy.c (pass_data_copy_prop::clone): Likewise.
	* tree-ssa-copyrename.c (pass_rename_ssa_copies::clone): Likewise.
	* tree-ssa-dce.c (pass_dce::clone, pass_dce_loop::clone): Likewise.
	(pass_cd_dce::clone): Likewise.
	* tree-ssa-dom.c (pass_dominator::clone): Likewise.
	(pass_phi_only_cprop::clone): Likewise.
	* tree-ssa-dse.c (pass_dse::clone): Likewise.
	* tree-ssa-forwprop.c (pass_forwprop::clone): Likewise.
	* tree-ssa-loop.c (pass_lim::clone): Likewise.
	* tree-ssa-phiopt.c (pass_phiopt::clone): Likewise.
	* tree-ssa-pre.c (pass_fre::clone): Likewise.
	* tree-ssa-reassoc.c (pass_reassoc::clone): Likewise.
	* tree-ssa-uninit.c (pass_late_warn_uninitialized::clone): Likewise.
	* tree-tailcall.c (pass_tail_recursion::clone): Likewise.
	* tree-vect-generic.c (pass_lower_vector_ssa::clone): Likewise.
	* tree-vrp.c (pass_vrp::clone): Likewise.
	* tsan.c (pass_tsan::clone): Likewise.

From-SVN: r203046
---

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d125ced29c8..e3a5c820e0a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,67 @@
+2013-09-30  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* basic-block.h (edge_list): Prefix member names with "m_".
+	* context.h (context): Likewise.
+	* domwalk.h (dom_walker): Likewise.
+	* gengtype-state.c (s_expr_writer, state_writer): Likewise.
+	* graphite-sese-to-poly.c (sese_dom_walker): Likewise.
+	* hash-table.h (hash_table): Likewise.
+	* machmode.h (bit_field_mode_iterator): Likewise.
+	* pass_manager.h (pass_list): Likewise.
+	* tree-into-ssa.c (mark_def_dom_walker): Likewise.
+	* tree-pass.h (pass_data): Likewise.
+	* tree-ssa-dom.c (dom_opt_dom_walker): Likewise.
+	* tree-ssa-phiopt.c (nontrapping_dom_walker): Likewise,
+	* tree-ssa-uncprop.c (uncprop_dom_walker): Likewise.
+	* asan.c (pass_data_asan): Update accordingly.
+	* cfganal.c (control_dependences::find_control_dependence): Likewise.
+	(control_dependences::control_dependences): Likewise.
+	(control_dependences::~control_dependences): Likewise.
+	(control_dependences::~control_dependences): Likewise.
+	(control_dependences::get_edges_dependent_on): Likewise.
+	* cgraphbuild.c (pass_data_rebuild_cgraph_edges::clone): Likewise.
+	(pass_data_remove_cgraph_callee_edges::clone): Likewise.
+	* context.c (gcc::context::context): Likewise.
+	* cprop.c (pass_rtl_cprop::clone): Likewise.
+	* domwalk.c (dom_walker::walk): Likewise.
+	* ipa-inline-analysis.c (pass_inline_parameters::clone): Likewise.
+	* ipa-pure-const.c (pass_local_pure_const::clone): Likewise.
+	* mode-switching.c (pass_mode_switching::clone): Likewise.
+	* passes.c (opt_pass::opt_pass): Likewise.
+	(pass_manager::pass_manager): Likewise.
+	* predict.c (pass_strip_predict_hints::clone): Likewise.
+	* recog.c (pass_data pass_data_peephole2::clone): Likewise.
+	(pass_split_all_insns::clone): Likewise.
+	* stor-layout.c (bit_field_mode_iterator::bit_field_mode_iterator):
+	Likewise.
+	(bit_field_mode_iterator::next_mode): Likewise.
+	(bit_field_mode_iterator::prefer_smaller_modes): Likewise.
+	* tree-cfg.c (pass_split_crit_edges::clone): Likewise.
+	* tree-cfgcleanup.c (pass_merge_phi::clone): Likewise.
+	* tree-complex.c (pass_lower_complex::clone): Likewise.
+	* tree-eh.c (pass_cleanup_eh::clone): Likewise.
+	* tree-object-size.c (pass_object_sizes::clone): Likewise.
+	* tree-optimize.c (pass_fixup_cfg::clone): Likewise.
+	* tree-ssa-ccp.c (pass_data_ccp::clone): Likewise.
+	(pass_fold_builtins::clone): Likewise.
+	* tree-ssa-copy.c (pass_data_copy_prop::clone): Likewise.
+	* tree-ssa-copyrename.c (pass_rename_ssa_copies::clone): Likewise.
+	* tree-ssa-dce.c (pass_dce::clone, pass_dce_loop::clone): Likewise.
+	(pass_cd_dce::clone): Likewise.
+	* tree-ssa-dom.c (pass_dominator::clone): Likewise.
+	(pass_phi_only_cprop::clone): Likewise.
+	* tree-ssa-dse.c (pass_dse::clone): Likewise.
+	* tree-ssa-forwprop.c (pass_forwprop::clone): Likewise.
+	* tree-ssa-loop.c (pass_lim::clone): Likewise.
+	* tree-ssa-phiopt.c (pass_phiopt::clone): Likewise.
+	* tree-ssa-pre.c (pass_fre::clone): Likewise.
+	* tree-ssa-reassoc.c (pass_reassoc::clone): Likewise.
+	* tree-ssa-uninit.c (pass_late_warn_uninitialized::clone): Likewise.
+	* tree-tailcall.c (pass_tail_recursion::clone): Likewise.
+	* tree-vect-generic.c (pass_lower_vector_ssa::clone): Likewise.
+	* tree-vrp.c (pass_vrp::clone): Likewise.
+	* tsan.c (pass_tsan::clone): Likewise.
+
 2013-09-30  Jakub Jelinek  <jakub@redhat.com>
 
 	PR middle-end/58564
diff --git a/gcc/asan.c b/gcc/asan.c
index 688c2310e81..c037ebfd62f 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -2273,7 +2273,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_asan (ctxt_); }
+  opt_pass * clone () { return new pass_asan (m_ctxt); }
   bool gate () { return gate_asan (); }
   unsigned int execute () { return asan_instrument (); }
 
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index b68cb453d36..acb5ea8d54a 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -479,7 +479,7 @@ private:
   void clear_control_dependence_bitmap (basic_block);
   void find_control_dependence (int);
   vec<bitmap> control_dependence_map;
-  edge_list *el;
+  edge_list *m_el;
 };
 
 /* The base value for branch probability notes and edge probabilities.  */
diff --git a/gcc/cfganal.c b/gcc/cfganal.c
index c4ea7dd0a1f..56853b9be13 100644
--- a/gcc/cfganal.c
+++ b/gcc/cfganal.c
@@ -389,18 +389,18 @@ control_dependences::find_control_dependence (int edge_index)
   basic_block current_block;
   basic_block ending_block;
 
-  gcc_assert (INDEX_EDGE_PRED_BB (el, edge_index) != EXIT_BLOCK_PTR);
+  gcc_assert (INDEX_EDGE_PRED_BB (m_el, edge_index) != EXIT_BLOCK_PTR);
 
-  if (INDEX_EDGE_PRED_BB (el, edge_index) == ENTRY_BLOCK_PTR)
+  if (INDEX_EDGE_PRED_BB (m_el, edge_index) == ENTRY_BLOCK_PTR)
     ending_block = single_succ (ENTRY_BLOCK_PTR);
   else
-    ending_block = find_pdom (INDEX_EDGE_PRED_BB (el, edge_index));
+    ending_block = find_pdom (INDEX_EDGE_PRED_BB (m_el, edge_index));
 
-  for (current_block = INDEX_EDGE_SUCC_BB (el, edge_index);
+  for (current_block = INDEX_EDGE_SUCC_BB (m_el, edge_index);
        current_block != ending_block && current_block != EXIT_BLOCK_PTR;
        current_block = find_pdom (current_block))
     {
-      edge e = INDEX_EDGE (el, edge_index);
+      edge e = INDEX_EDGE (m_el, edge_index);
 
       /* For abnormal edges, we don't make current_block control
 	 dependent because instructions that throw are always necessary
@@ -416,13 +416,13 @@ control_dependences::find_control_dependence (int edge_index)
    list EL, ala Morgan, Section 3.6.  */
 
 control_dependences::control_dependences (struct edge_list *edges)
-  : el (edges)
+  : m_el (edges)
 {
   timevar_push (TV_CONTROL_DEPENDENCES);
   control_dependence_map.create (last_basic_block);
   for (int i = 0; i < last_basic_block; ++i)
     control_dependence_map.quick_push (BITMAP_ALLOC (NULL));
-  for (int i = 0; i < NUM_EDGES (el); ++i)
+  for (int i = 0; i < NUM_EDGES (m_el); ++i)
     find_control_dependence (i);
   timevar_pop (TV_CONTROL_DEPENDENCES);
 }
@@ -434,7 +434,7 @@ control_dependences::~control_dependences ()
   for (unsigned i = 0; i < control_dependence_map.length (); ++i)
     BITMAP_FREE (control_dependence_map[i]);
   control_dependence_map.release ();
-  free_edge_list (el);
+  free_edge_list (m_el);
 }
 
 /* Returns the bitmap of edges the basic-block I is dependent on.  */
@@ -450,7 +450,7 @@ control_dependences::get_edges_dependent_on (int i)
 edge
 control_dependences::get_edge (int i)
 {
-  return INDEX_EDGE (el, i);
+  return INDEX_EDGE (m_el, i);
 }
 
 
diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
index 4cf562ecdd5..1b73a144f08 100644
--- a/gcc/cgraphbuild.c
+++ b/gcc/cgraphbuild.c
@@ -530,7 +530,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_rebuild_cgraph_edges (ctxt_); }
+  opt_pass * clone () { return new pass_rebuild_cgraph_edges (m_ctxt); }
   unsigned int execute () { return rebuild_cgraph_edges (); }
 
 }; // class pass_rebuild_cgraph_edges
@@ -579,7 +579,7 @@ public:
 
   /* opt_pass methods: */
   opt_pass * clone () {
-    return new pass_remove_cgraph_callee_edges (ctxt_);
+    return new pass_remove_cgraph_callee_edges (m_ctxt);
   }
   unsigned int execute () { return remove_cgraph_callee_edges (); }
 
diff --git a/gcc/context.c b/gcc/context.c
index 6bd25f01852..09e1f898f7a 100644
--- a/gcc/context.c
+++ b/gcc/context.c
@@ -29,5 +29,5 @@ gcc::context *g;
 
 gcc::context::context ()
 {
-  passes_ = new gcc::pass_manager (this);
+  m_passes = new gcc::pass_manager (this);
 }
diff --git a/gcc/context.h b/gcc/context.h
index ed6a24a8f5c..4aab6de9a9a 100644
--- a/gcc/context.h
+++ b/gcc/context.h
@@ -34,11 +34,11 @@ public:
 
   /* Pass-management.  */
 
-  pass_manager *get_passes () { gcc_assert (passes_); return passes_; }
+  pass_manager *get_passes () { gcc_assert (m_passes); return m_passes; }
 
 private:
   /* Pass-management.  */
-  pass_manager *passes_;
+  pass_manager *m_passes;
 
 }; // class context
 
diff --git a/gcc/cprop.c b/gcc/cprop.c
index 9d6cb46654b..358fca9171a 100644
--- a/gcc/cprop.c
+++ b/gcc/cprop.c
@@ -1940,7 +1940,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_rtl_cprop (ctxt_); }
+  opt_pass * clone () { return new pass_rtl_cprop (m_ctxt); }
   bool gate () { return gate_rtl_cprop (); }
   unsigned int execute () { return execute_rtl_cprop (); }
 
diff --git a/gcc/domwalk.c b/gcc/domwalk.c
index bffa4aa4851..4816b4c8d85 100644
--- a/gcc/domwalk.c
+++ b/gcc/domwalk.c
@@ -154,7 +154,7 @@ dom_walker::walk (basic_block bb)
   int sp = 0;
   int *postorder, postorder_num;
 
-  if (dom_direction_ == CDI_DOMINATORS)
+  if (m_dom_direction == CDI_DOMINATORS)
     {
       postorder = XNEWVEC (int, n_basic_blocks);
       postorder_num = inverted_post_order_compute (postorder);
@@ -181,10 +181,10 @@ dom_walker::walk (basic_block bb)
 	  worklist[sp++] = NULL;
 
 	  int saved_sp = sp;
-	  for (dest = first_dom_son (dom_direction_, bb);
-	       dest; dest = next_dom_son (dom_direction_, dest))
+	  for (dest = first_dom_son (m_dom_direction, bb);
+	       dest; dest = next_dom_son (m_dom_direction, dest))
 	    worklist[sp++] = dest;
-	  if (dom_direction_ == CDI_DOMINATORS)
+	  if (m_dom_direction == CDI_DOMINATORS)
 	    switch (sp - saved_sp)
 	      {
 	      case 0:
@@ -210,7 +210,7 @@ dom_walker::walk (basic_block bb)
       else
 	break;
     }
-  if (dom_direction_ == CDI_DOMINATORS)
+  if (m_dom_direction == CDI_DOMINATORS)
     {
       free (bb_postorder);
       bb_postorder = NULL;
diff --git a/gcc/domwalk.h b/gcc/domwalk.h
index b33d70eda23..43c15740f7a 100644
--- a/gcc/domwalk.h
+++ b/gcc/domwalk.h
@@ -30,7 +30,7 @@ along with GCC; see the file COPYING3.  If not see
 class dom_walker
 {
 public:
-  dom_walker (cdi_direction direction) : dom_direction_ (direction) {}
+  dom_walker (cdi_direction direction) : m_dom_direction (direction) {}
 
   /* Walk the dominator tree.  */
   void walk (basic_block);
@@ -46,7 +46,7 @@ private:
      if it is set to CDI_DOMINATORS, then we walk the dominator tree,
      if it is set to CDI_POST_DOMINATORS, then we walk the post
      dominator tree.  */
-  const ENUM_BITFIELD (cdi_direction) dom_direction_ : 2;
+  const ENUM_BITFIELD (cdi_direction) m_dom_direction : 2;
 };
 
 #endif
diff --git a/gcc/gengtype-state.c b/gcc/gengtype-state.c
index a019aaf353e..96ecc7cdaf8 100644
--- a/gcc/gengtype-state.c
+++ b/gcc/gengtype-state.c
@@ -151,8 +151,8 @@ public:
   void end_s_expr ();
 
 private:
-  int indent_amount_;
-  int had_recent_newline_;
+  int m_indent_amount;
+  int m_had_recent_newline;
 }; // class s_expr_writer
 
 /* A class for writing out "gtype.state".  */
@@ -200,14 +200,14 @@ private:
 
 private:
   /* Counter of written types.  */
-  int state_written_type_count;
+  int m_state_written_type_count;
 }; // class state_writer
 
 
 /* class s_expr_writer's trivial constructor.  */
 s_expr_writer::s_expr_writer ()
-  : indent_amount_(0),
-    had_recent_newline_(0)
+  : m_indent_amount (0),
+    m_had_recent_newline (0)
 {
 }
 
@@ -216,10 +216,10 @@ void
 s_expr_writer::write_new_line (void)
 {
   /* Don't add a newline if we've just had one.  */
-  if (!had_recent_newline_)
+  if (!m_had_recent_newline)
     {
       fprintf (state_file, "\n");
-      had_recent_newline_ = 1;
+      m_had_recent_newline = 1;
     }
 }
 
@@ -236,11 +236,11 @@ void
 s_expr_writer::write_any_indent (int leading_spaces)
 {
   int i;
-  int amount = indent_amount_ - leading_spaces;
-  if (had_recent_newline_)
+  int amount = m_indent_amount - leading_spaces;
+  if (m_had_recent_newline)
     for (i = 0; i < amount; i++)
       fprintf (state_file, " ");
-  had_recent_newline_ = 0;
+  m_had_recent_newline = 0;
 }
 
 /* Write the beginning of a new s-expresion e.g. "(!foo "
@@ -253,7 +253,7 @@ s_expr_writer::begin_s_expr (const char *tag)
   write_new_line ();
   write_any_indent (0);
   fprintf (state_file, "(!%s ", tag);
-  indent_amount_++;
+  m_indent_amount++;
 }
 
 /* Write out the end of an s-expression: any necssessary indentation,
@@ -261,7 +261,7 @@ s_expr_writer::begin_s_expr (const char *tag)
 void
 s_expr_writer::end_s_expr (void)
 {
-  indent_amount_--;
+  m_indent_amount--;
   write_any_indent (0);
   fprintf (state_file, ")");
   write_new_line ();
@@ -271,7 +271,7 @@ s_expr_writer::end_s_expr (void)
 /* class state_writer's trivial constructor.  */
 state_writer::state_writer ()
   : s_expr_writer (),
-    state_written_type_count (0)
+    m_state_written_type_count (0)
 {
 }
 
@@ -1136,10 +1136,10 @@ state_writer::write_state_type (type_p current)
     }
   else
     {
-      state_written_type_count++;
-      DBGPRINTF ("writing type #%d @%p old number %d", state_written_type_count,
+      m_state_written_type_count++;
+      DBGPRINTF ("writing type #%d @%p old number %d", m_state_written_type_count,
 		 (void *) current, current->state_number);
-      current->state_number = state_written_type_count;
+      current->state_number = m_state_written_type_count;
       switch (current->kind)
 	{
 	case TYPE_NONE:
@@ -1441,7 +1441,7 @@ write_state (const char *state_path)
 
   if (verbosity_level >= 1)
     printf ("%s wrote state file %s of %ld bytes with %d GTY-ed types\n",
-	    progname, state_path, statelen, sw.state_written_type_count);
+	    progname, state_path, statelen, sw.m_state_written_type_count);
 
 }
 
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index 3949098f83c..2d882060ab5 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -1226,21 +1226,21 @@ public:
   virtual void after_dom_children (basic_block);
 
 private:
-  vec<gimple> conditions_, cases_;
-  sese region_;
+  vec<gimple> m_conditions, m_cases;
+  sese m_region;
 };
 
 sese_dom_walker::sese_dom_walker (cdi_direction direction, sese region)
-  : dom_walker (direction), region_ (region)
+  : dom_walker (direction), m_region (region)
 {
-  conditions_.create (3);
-  cases_.create (3);
+  m_conditions.create (3);
+  m_cases.create (3);
 }
 
 sese_dom_walker::~sese_dom_walker ()
 {
-  conditions_.release ();
-  cases_.release ();
+  m_conditions.release ();
+  m_cases.release ();
 }
 
 /* Call-back for dom_walk executed before visiting the dominated
@@ -1252,7 +1252,7 @@ sese_dom_walker::before_dom_children (basic_block bb)
   gimple_bb_p gbb;
   gimple stmt;
 
-  if (!bb_in_sese_p (bb, region_))
+  if (!bb_in_sese_p (bb, m_region))
     return;
 
   stmt = single_pred_cond_non_loop_exit (bb);
@@ -1261,20 +1261,20 @@ sese_dom_walker::before_dom_children (basic_block bb)
     {
       edge e = single_pred_edge (bb);
 
-      conditions_.safe_push (stmt);
+      m_conditions.safe_push (stmt);
 
       if (e->flags & EDGE_TRUE_VALUE)
-	cases_.safe_push (stmt);
+	m_cases.safe_push (stmt);
       else
-	cases_.safe_push (NULL);
+	m_cases.safe_push (NULL);
     }
 
   gbb = gbb_from_bb (bb);
 
   if (gbb)
     {
-      GBB_CONDITIONS (gbb) = conditions_.copy ();
-      GBB_CONDITION_CASES (gbb) = cases_.copy ();
+      GBB_CONDITIONS (gbb) = m_conditions.copy ();
+      GBB_CONDITION_CASES (gbb) = m_cases.copy ();
     }
 }
 
@@ -1284,13 +1284,13 @@ sese_dom_walker::before_dom_children (basic_block bb)
 void
 sese_dom_walker::after_dom_children (basic_block bb)
 {
-  if (!bb_in_sese_p (bb, region_))
+  if (!bb_in_sese_p (bb, m_region))
     return;
 
   if (single_pred_cond_non_loop_exit (bb))
     {
-      conditions_.pop ();
-      cases_.pop ();
+      m_conditions.pop ();
+      m_cases.pop ();
     }
 }
 
diff --git a/gcc/hash-table.h b/gcc/hash-table.h
index 6d01188fe40..5f80efb6bf4 100644
--- a/gcc/hash-table.h
+++ b/gcc/hash-table.h
@@ -419,8 +419,8 @@ public:
     inline iterator &operator ++ ();
     inline bool operator != (const iterator &) const;
   private:
-    value_type **slot_;
-    value_type **limit_;
+    value_type **m_slot;
+    value_type **m_limit;
   };
 
 private:
@@ -959,7 +959,7 @@ template <typename Descriptor,
 	  template <typename Type> class Allocator>
 inline
 hash_table <Descriptor, Allocator>::iterator::iterator ()
-: slot_ (NULL), limit_ (NULL)
+: m_slot (NULL), m_limit (NULL)
 {
 }
 
@@ -970,7 +970,7 @@ template <typename Descriptor,
 inline
 hash_table <Descriptor, Allocator>::iterator::iterator
    (value_type **slot, value_type **limit)
-: slot_ (slot), limit_ (limit)
+: m_slot (slot), m_limit (limit)
 {
 }
 
@@ -981,7 +981,7 @@ template <typename Descriptor,
 inline typename hash_table <Descriptor, Allocator>::value_type &
 hash_table <Descriptor, Allocator>::iterator::operator * ()
 {
-  return **slot_;
+  return **m_slot;
 }
 
 /* Slide down the iterator slots until an active entry is found.  */
@@ -991,14 +991,14 @@ template <typename Descriptor,
 void
 hash_table <Descriptor, Allocator>::iterator::slide ()
 {
-  for ( ; slot_ < limit_; ++slot_ )
+  for ( ; m_slot < m_limit; ++m_slot )
     {
-      value_type *x = *slot_;
+      value_type *x = *m_slot;
       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
         return;
     }
-  slot_ = NULL;
-  limit_ = NULL;
+  m_slot = NULL;
+  m_limit = NULL;
 }
 
 /* Bump the iterator.  */
@@ -1008,7 +1008,7 @@ template <typename Descriptor,
 inline typename hash_table <Descriptor, Allocator>::iterator &
 hash_table <Descriptor, Allocator>::iterator::operator ++ ()
 {
-  ++slot_;
+  ++m_slot;
   slide ();
   return *this;
 }
@@ -1021,7 +1021,7 @@ inline bool
 hash_table <Descriptor, Allocator>::iterator::
   operator != (const iterator &other) const
 {
-  return slot_ != other.slot_ || limit_ != other.limit_;
+  return m_slot != other.m_slot || m_limit != other.m_limit;
 }
 
 /* Hash table iterator producers.  */
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 00a21d9288a..7ca09ad0b91 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -2744,7 +2744,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_inline_parameters (ctxt_); }
+  opt_pass * clone () { return new pass_inline_parameters (m_ctxt); }
   unsigned int execute () {
     return compute_inline_parameters_for_current ();
   }
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index bc0a17bc5dc..7e44d51ca59 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -1709,7 +1709,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_local_pure_const (ctxt_); }
+  opt_pass * clone () { return new pass_local_pure_const (m_ctxt); }
   bool gate () { return gate_pure_const (); }
   unsigned int execute () { return local_pure_const (); }
 
diff --git a/gcc/machmode.h b/gcc/machmode.h
index 981ee92a87a..da0923a81a2 100644
--- a/gcc/machmode.h
+++ b/gcc/machmode.h
@@ -269,16 +269,16 @@ public:
   bool prefer_smaller_modes ();
 
 private:
-  enum machine_mode mode_;
+  enum machine_mode m_mode;
   /* We use signed values here because the bit position can be negative
      for invalid input such as gcc.dg/pr48335-8.c.  */
-  HOST_WIDE_INT bitsize_;
-  HOST_WIDE_INT bitpos_;
-  HOST_WIDE_INT bitregion_start_;
-  HOST_WIDE_INT bitregion_end_;
-  unsigned int align_;
-  bool volatilep_;
-  int count_;
+  HOST_WIDE_INT m_bitsize;
+  HOST_WIDE_INT m_bitpos;
+  HOST_WIDE_INT m_bitregion_start;
+  HOST_WIDE_INT m_bitregion_end;
+  unsigned int m_align;
+  bool m_volatilep;
+  int m_count;
 };
 
 /* Find the best mode to use to access a bit field.  */
diff --git a/gcc/mode-switching.c b/gcc/mode-switching.c
index 23ed63b10f8..483566b25f6 100644
--- a/gcc/mode-switching.c
+++ b/gcc/mode-switching.c
@@ -811,7 +811,7 @@ public:
   /* opt_pass methods: */
   /* The epiphany backend creates a second instance of this pass, so we need
      a clone method.  */
-  opt_pass * clone () { return new pass_mode_switching (ctxt_); }
+  opt_pass * clone () { return new pass_mode_switching (m_ctxt); }
   bool gate () { return gate_mode_switching (); }
   unsigned int execute () { return rest_of_handle_mode_switching (); }
 
diff --git a/gcc/pass_manager.h b/gcc/pass_manager.h
index cca6a3567cd..77d78eb11f5 100644
--- a/gcc/pass_manager.h
+++ b/gcc/pass_manager.h
@@ -97,7 +97,7 @@ private:
   void register_dump_files (struct opt_pass *pass, int properties);
 
 private:
-  context *ctxt_;
+  context *m_ctxt;
 
   /* References to all of the individual passes.
      These fields are generated via macro expansion.
diff --git a/gcc/passes.c b/gcc/passes.c
index e64281e1d53..e7b7b9a992f 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -112,7 +112,7 @@ opt_pass::opt_pass (const pass_data &data, context *ctxt)
     sub (NULL),
     next (NULL),
     static_pass_number (0),
-    ctxt_ (ctxt)
+    m_ctxt (ctxt)
 {
 }
 
@@ -1488,7 +1488,7 @@ pass_manager::pass_manager (context *ctxt)
 : all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
   all_regular_ipa_passes (NULL), all_lto_gen_passes (NULL),
   all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
-  ctxt_ (ctxt)
+  m_ctxt (ctxt)
 {
   struct opt_pass **p;
 
@@ -1513,7 +1513,7 @@ pass_manager::pass_manager (context *ctxt)
   do { \
     gcc_assert (NULL == PASS ## _ ## NUM); \
     if ((NUM) == 1)                              \
-      PASS ## _1 = make_##PASS (ctxt_);          \
+      PASS ## _1 = make_##PASS (m_ctxt);          \
     else                                         \
       {                                          \
         gcc_assert (PASS ## _1);                 \
diff --git a/gcc/predict.c b/gcc/predict.c
index 2472fca81cd..4815e75248e 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -3000,7 +3000,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_strip_predict_hints (ctxt_); }
+  opt_pass * clone () { return new pass_strip_predict_hints (m_ctxt); }
   unsigned int execute () { return strip_predict_hints (); }
 
 }; // class pass_strip_predict_hints
diff --git a/gcc/recog.c b/gcc/recog.c
index f64753ad6ca..a3ca98c62fd 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -3808,7 +3808,7 @@ public:
   /* opt_pass methods: */
   /* The epiphany backend creates a second instance of this pass, so we need
      a clone method.  */
-  opt_pass * clone () { return new pass_peephole2 (ctxt_); }
+  opt_pass * clone () { return new pass_peephole2 (m_ctxt); }
   bool gate () { return gate_handle_peephole2 (); }
   unsigned int execute () { return rest_of_handle_peephole2 (); }
 
@@ -3856,7 +3856,7 @@ public:
   /* opt_pass methods: */
   /* The epiphany backend creates a second instance of this pass, so
      we need a clone method.  */
-  opt_pass * clone () { return new pass_split_all_insns (ctxt_); }
+  opt_pass * clone () { return new pass_split_all_insns (m_ctxt); }
   unsigned int execute () { return rest_of_handle_split_all_insns (); }
 
 }; // class pass_split_all_insns
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 02998365804..6584b575e0f 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -2627,12 +2627,12 @@ bit_field_mode_iterator
 			   HOST_WIDE_INT bitregion_start,
 			   HOST_WIDE_INT bitregion_end,
 			   unsigned int align, bool volatilep)
-: mode_ (GET_CLASS_NARROWEST_MODE (MODE_INT)), bitsize_ (bitsize),
-  bitpos_ (bitpos), bitregion_start_ (bitregion_start),
-  bitregion_end_ (bitregion_end), align_ (align),
-  volatilep_ (volatilep), count_ (0)
+: m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT)), m_bitsize (bitsize),
+  m_bitpos (bitpos), m_bitregion_start (bitregion_start),
+  m_bitregion_end (bitregion_end), m_align (align),
+  m_volatilep (volatilep), m_count (0)
 {
-  if (!bitregion_end_)
+  if (!m_bitregion_end)
     {
       /* We can assume that any aligned chunk of ALIGN bits that overlaps
 	 the bitfield is mapped and won't trap, provided that ALIGN isn't
@@ -2642,8 +2642,8 @@ bit_field_mode_iterator
 	= MIN (align, MAX (BIGGEST_ALIGNMENT, BITS_PER_WORD));
       if (bitsize <= 0)
 	bitsize = 1;
-      bitregion_end_ = bitpos + bitsize + units - 1;
-      bitregion_end_ -= bitregion_end_ % units + 1;
+      m_bitregion_end = bitpos + bitsize + units - 1;
+      m_bitregion_end -= m_bitregion_end % units + 1;
     }
 }
 
@@ -2654,12 +2654,12 @@ bit_field_mode_iterator
 bool
 bit_field_mode_iterator::next_mode (enum machine_mode *out_mode)
 {
-  for (; mode_ != VOIDmode; mode_ = GET_MODE_WIDER_MODE (mode_))
+  for (; m_mode != VOIDmode; m_mode = GET_MODE_WIDER_MODE (m_mode))
     {
-      unsigned int unit = GET_MODE_BITSIZE (mode_);
+      unsigned int unit = GET_MODE_BITSIZE (m_mode);
 
       /* Skip modes that don't have full precision.  */
-      if (unit != GET_MODE_PRECISION (mode_))
+      if (unit != GET_MODE_PRECISION (m_mode))
 	continue;
 
       /* Stop if the mode is too wide to handle efficiently.  */
@@ -2668,31 +2668,31 @@ bit_field_mode_iterator::next_mode (enum machine_mode *out_mode)
 
       /* Don't deliver more than one multiword mode; the smallest one
 	 should be used.  */
-      if (count_ > 0 && unit > BITS_PER_WORD)
+      if (m_count > 0 && unit > BITS_PER_WORD)
 	break;
 
       /* Skip modes that are too small.  */
-      unsigned HOST_WIDE_INT substart = (unsigned HOST_WIDE_INT) bitpos_ % unit;
-      unsigned HOST_WIDE_INT subend = substart + bitsize_;
+      unsigned HOST_WIDE_INT substart = (unsigned HOST_WIDE_INT) m_bitpos % unit;
+      unsigned HOST_WIDE_INT subend = substart + m_bitsize;
       if (subend > unit)
 	continue;
 
       /* Stop if the mode goes outside the bitregion.  */
-      HOST_WIDE_INT start = bitpos_ - substart;
-      if (bitregion_start_ && start < bitregion_start_)
+      HOST_WIDE_INT start = m_bitpos - substart;
+      if (m_bitregion_start && start < m_bitregion_start)
 	break;
       HOST_WIDE_INT end = start + unit;
-      if (end > bitregion_end_ + 1)
+      if (end > m_bitregion_end + 1)
 	break;
 
       /* Stop if the mode requires too much alignment.  */
-      if (GET_MODE_ALIGNMENT (mode_) > align_
-	  && SLOW_UNALIGNED_ACCESS (mode_, align_))
+      if (GET_MODE_ALIGNMENT (m_mode) > m_align
+	  && SLOW_UNALIGNED_ACCESS (m_mode, m_align))
 	break;
 
-      *out_mode = mode_;
-      mode_ = GET_MODE_WIDER_MODE (mode_);
-      count_++;
+      *out_mode = m_mode;
+      m_mode = GET_MODE_WIDER_MODE (m_mode);
+      m_count++;
       return true;
     }
   return false;
@@ -2704,7 +2704,7 @@ bit_field_mode_iterator::next_mode (enum machine_mode *out_mode)
 bool
 bit_field_mode_iterator::prefer_smaller_modes ()
 {
-  return (volatilep_
+  return (m_volatilep
 	  ? targetm.narrow_volatile_bitfield ()
 	  : !SLOW_BYTE_ACCESS);
 }
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index f0dd2bc5039..b72ac61373c 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -7967,7 +7967,7 @@ public:
   /* opt_pass methods: */
   unsigned int execute () { return split_critical_edges (); }
 
-  opt_pass * clone () { return new pass_split_crit_edges (ctxt_); }
+  opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
 }; // class pass_split_crit_edges
 
 } // anon namespace
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index 37d6d03822b..cd4307ec9b8 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -1014,7 +1014,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_merge_phi (ctxt_); }
+  opt_pass * clone () { return new pass_merge_phi (m_ctxt); }
   bool gate () { return gate_merge_phi (); }
   unsigned int execute () { return merge_phi_nodes (); }
 
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index 0f26ab68de9..7d9b696d9a8 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -1662,7 +1662,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_lower_complex (ctxt_); }
+  opt_pass * clone () { return new pass_lower_complex (m_ctxt); }
   unsigned int execute () { return tree_lower_complex (); }
 
 }; // class pass_lower_complex
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index e8462cff4a4..1ad5baf5828 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -4541,7 +4541,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_cleanup_eh (ctxt_); }
+  opt_pass * clone () { return new pass_cleanup_eh (m_ctxt); }
   bool gate () { return gate_cleanup_eh (); }
   unsigned int execute () { return execute_cleanup_eh (); }
 
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index 2fe710e1bfb..18b00a888ea 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -2235,17 +2235,17 @@ private:
   /* Notice that this bitmap is indexed using variable UIDs, so it must be
      large enough to accommodate all the variables referenced in the
      function, not just the ones we are renaming.  */
-  bitmap kills_;
+  bitmap m_kills;
 };
 
 mark_def_dom_walker::mark_def_dom_walker (cdi_direction direction)
-  : dom_walker (direction), kills_ (BITMAP_ALLOC (NULL))
+  : dom_walker (direction), m_kills (BITMAP_ALLOC (NULL))
 {
 }
 
 mark_def_dom_walker::~mark_def_dom_walker ()
 {
-  BITMAP_FREE (kills_);
+  BITMAP_FREE (m_kills);
 }
 
 /* Block processing routine for mark_def_sites.  Clear the KILLS bitmap
@@ -2256,9 +2256,9 @@ mark_def_dom_walker::before_dom_children (basic_block bb)
 {
   gimple_stmt_iterator gsi;
 
-  bitmap_clear (kills_);
+  bitmap_clear (m_kills);
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    mark_def_sites (bb, gsi_stmt (gsi), kills_);
+    mark_def_sites (bb, gsi_stmt (gsi), m_kills);
 }
 
 /* Initialize internal data needed during renaming.  */
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index 9721457262b..0bdbc489f8c 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -1288,7 +1288,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_object_sizes (ctxt_); }
+  opt_pass * clone () { return new pass_object_sizes (m_ctxt); }
   unsigned int execute () { return compute_object_sizes (); }
 
 }; // class pass_object_sizes
diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c
index 66631464885..445bd7c7a91 100644
--- a/gcc/tree-optimize.c
+++ b/gcc/tree-optimize.c
@@ -255,7 +255,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_fixup_cfg (ctxt_); }
+  opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
   unsigned int execute () { return execute_fixup_cfg (); }
 
 }; // class pass_fixup_cfg
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index 3400329b3c1..e72fe9aeee4 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -115,7 +115,7 @@ public:
   int static_pass_number;
 
 protected:
-  gcc::context *ctxt_;
+  gcc::context *m_ctxt;
 };
 
 /* Description of GIMPLE pass.  */
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 849e9e92702..fe21c0727a1 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -2171,7 +2171,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_ccp (ctxt_); }
+  opt_pass * clone () { return new pass_ccp (m_ctxt); }
   bool gate () { return gate_ccp (); }
   unsigned int execute () { return do_ssa_ccp (); }
 
@@ -2588,7 +2588,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_fold_builtins (ctxt_); }
+  opt_pass * clone () { return new pass_fold_builtins (m_ctxt); }
   unsigned int execute () { return execute_fold_all_builtins (); }
 
 }; // class pass_fold_builtins
diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index a20fc97f2ad..5ab5389a7fa 100644
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -863,7 +863,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_copy_prop (ctxt_); }
+  opt_pass * clone () { return new pass_copy_prop (m_ctxt); }
   bool gate () { return gate_copy_prop (); }
   unsigned int execute () { return execute_copy_prop (); }
 
diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c
index f4395e44cb7..d8660c56e62 100644
--- a/gcc/tree-ssa-copyrename.c
+++ b/gcc/tree-ssa-copyrename.c
@@ -460,7 +460,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_rename_ssa_copies (ctxt_); }
+  opt_pass * clone () { return new pass_rename_ssa_copies (m_ctxt); }
   bool gate () { return gate_copyrename (); }
   unsigned int execute () { return rename_ssa_copies (); }
 
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index c132baf82ee..c20a13a04c8 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -1565,7 +1565,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_dce (ctxt_); }
+  opt_pass * clone () { return new pass_dce (m_ctxt); }
   bool gate () { return gate_dce (); }
   unsigned int execute () { return tree_ssa_dce (); }
 
@@ -1604,7 +1604,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_dce_loop (ctxt_); }
+  opt_pass * clone () { return new pass_dce_loop (m_ctxt); }
   bool gate () { return gate_dce (); }
   unsigned int execute () { return tree_ssa_dce_loop (); }
 
@@ -1643,7 +1643,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_cd_dce (ctxt_); }
+  opt_pass * clone () { return new pass_cd_dce (m_ctxt); }
   bool gate () { return gate_dce (); }
   unsigned int execute () { return tree_ssa_cd_dce (); }
 
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 495b6b8b957..7013f43e6a6 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -775,7 +775,7 @@ class dom_opt_dom_walker : public dom_walker
 {
 public:
   dom_opt_dom_walker (cdi_direction direction)
-    : dom_walker (direction), dummy_cond_ (NULL) {}
+    : dom_walker (direction), m_dummy_cond (NULL) {}
 
   virtual void before_dom_children (basic_block);
   virtual void after_dom_children (basic_block);
@@ -783,7 +783,7 @@ public:
 private:
   void thread_across_edge (edge);
 
-  gimple dummy_cond_;
+  gimple m_dummy_cond;
 };
 
 /* Jump threading, redundancy elimination and const/copy propagation.
@@ -940,7 +940,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_dominator (ctxt_); }
+  opt_pass * clone () { return new pass_dominator (m_ctxt); }
   bool gate () { return gate_dominator (); }
   unsigned int execute () { return tree_ssa_dominator_optimize (); }
 
@@ -1107,8 +1107,8 @@ record_temporary_equivalences (edge e)
 void
 dom_opt_dom_walker::thread_across_edge (edge e)
 {
-  if (! dummy_cond_)
-    dummy_cond_ =
+  if (! m_dummy_cond)
+    m_dummy_cond =
         gimple_build_cond (NE_EXPR,
                            integer_zero_node, integer_zero_node,
                            NULL, NULL);
@@ -1123,7 +1123,7 @@ dom_opt_dom_walker::thread_across_edge (edge e)
 
   /* With all the edge equivalences in the tables, go ahead and attempt
      to thread through E->dest.  */
-  ::thread_across_edge (dummy_cond_, e, false,
+  ::thread_across_edge (m_dummy_cond, e, false,
 		        &const_and_copies_stack,
 		        simplify_stmt_for_jump_threading);
 
@@ -3133,7 +3133,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_phi_only_cprop (ctxt_); }
+  opt_pass * clone () { return new pass_phi_only_cprop (m_ctxt); }
   bool gate () { return gate_dominator (); }
   unsigned int execute () { return eliminate_degenerate_phis (); }
 
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 45c8b2f685f..700824cade8 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -380,7 +380,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_dse (ctxt_); }
+  opt_pass * clone () { return new pass_dse (m_ctxt); }
   bool gate () { return gate_dse (); }
   unsigned int execute () { return tree_ssa_dse (); }
 
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index ee8240e35f1..8807db16a1b 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -3565,7 +3565,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_forwprop (ctxt_); }
+  opt_pass * clone () { return new pass_forwprop (m_ctxt); }
   bool gate () { return gate_forwprop (); }
   unsigned int execute () { return ssa_forward_propagate_and_combine (); }
 
diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
index 947f4d4782f..3952029d0ea 100644
--- a/gcc/tree-ssa-loop.c
+++ b/gcc/tree-ssa-loop.c
@@ -176,7 +176,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_lim (ctxt_); }
+  opt_pass * clone () { return new pass_lim (m_ctxt); }
   bool gate () { return gate_tree_ssa_loop_im (); }
   unsigned int execute () { return tree_ssa_loop_im (); }
 
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index d9dbed3e71b..c39419f0716 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -1379,13 +1379,13 @@ class nontrapping_dom_walker : public dom_walker
 {
 public:
   nontrapping_dom_walker (cdi_direction direction, pointer_set_t *ps)
-    : dom_walker (direction), nontrapping_ (ps) {}
+    : dom_walker (direction), m_nontrapping (ps) {}
 
   virtual void before_dom_children (basic_block);
   virtual void after_dom_children (basic_block);
 
 private:
-  pointer_set_t *nontrapping_;
+  pointer_set_t *m_nontrapping;
 };
 
 /* Called by walk_dominator_tree, when entering the block BB.  */
@@ -1416,8 +1416,8 @@ nontrapping_dom_walker::before_dom_children (basic_block bb)
 	nt_call_phase++;
       else if (gimple_assign_single_p (stmt) && !gimple_has_volatile_ops (stmt))
 	{
-	  add_or_mark_expr (bb, gimple_assign_lhs (stmt), nontrapping_, true);
-	  add_or_mark_expr (bb, gimple_assign_rhs1 (stmt), nontrapping_, false);
+	  add_or_mark_expr (bb, gimple_assign_lhs (stmt), m_nontrapping, true);
+	  add_or_mark_expr (bb, gimple_assign_rhs1 (stmt), m_nontrapping, false);
 	}
     }
 }
@@ -2039,7 +2039,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_phiopt (ctxt_); }
+  opt_pass * clone () { return new pass_phiopt (m_ctxt); }
   bool gate () { return gate_phiopt (); }
   unsigned int execute () { return tree_ssa_phiopt (); }
 
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 243f37e70a8..bd13476d31d 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -4865,7 +4865,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_fre (ctxt_); }
+  opt_pass * clone () { return new pass_fre (m_ctxt); }
   bool gate () { return gate_fre (); }
   unsigned int execute () { return execute_fre (); }
 
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 62c46a14598..cbf3a2d337e 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -4485,7 +4485,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_reassoc (ctxt_); }
+  opt_pass * clone () { return new pass_reassoc (m_ctxt); }
   bool gate () { return gate_tree_ssa_reassoc (); }
   unsigned int execute () { return execute_reassoc (); }
 
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 0bff196f899..28ff546c627 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -360,11 +360,11 @@ public:
   uncprop_dom_walker (cdi_direction direction)
     : dom_walker (direction)
   {
-    equiv_stack_.create (2);
+    m_equiv_stack.create (2);
   }
   ~uncprop_dom_walker ()
   {
-    equiv_stack_.release ();
+    m_equiv_stack.release ();
   }
 
   virtual void before_dom_children (basic_block);
@@ -372,11 +372,11 @@ public:
 
 private:
 
-/* As we enter each block we record the value for any edge equivalency
-   leading to this block.  If no such edge equivalency exists, then we
-   record NULL.  These equivalences are live until we leave the dominator
-   subtree rooted at the block where we record the equivalency.  */
-  vec<tree> equiv_stack_;
+  /* As we enter each block we record the value for any edge equivalency
+     leading to this block.  If no such edge equivalency exists, then we
+     record NULL.  These equivalences are live until we leave the dominator
+     subtree rooted at the block where we record the equivalency.  */
+  vec<tree> m_equiv_stack;
 };
 
 /* Main driver for un-cprop.  */
@@ -428,7 +428,7 @@ void
 uncprop_dom_walker::after_dom_children (basic_block bb ATTRIBUTE_UNUSED)
 {
   /* Pop the topmost value off the equiv stack.  */
-  tree value = equiv_stack_.pop ();
+  tree value = m_equiv_stack.pop ();
 
   /* If that value was non-null, then pop the topmost equivalency off
      its equivalency stack.  */
@@ -566,13 +566,13 @@ uncprop_dom_walker::before_dom_children (basic_block bb)
 	  struct edge_equivalency *equiv = (struct edge_equivalency *) e->aux;
 
 	  record_equiv (equiv->rhs, equiv->lhs);
-	  equiv_stack_.safe_push (equiv->rhs);
+	  m_equiv_stack.safe_push (equiv->rhs);
 	  recorded = true;
 	}
     }
 
   if (!recorded)
-    equiv_stack_.safe_push (NULL_TREE);
+    m_equiv_stack.safe_push (NULL_TREE);
 
   uncprop_into_successor_phis (bb);
 }
@@ -608,7 +608,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_uncprop (ctxt_); }
+  opt_pass * clone () { return new pass_uncprop (m_ctxt); }
   bool gate () { return gate_uncprop (); }
   unsigned int execute () { return tree_ssa_uncprop (); }
 
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 044efb34807..0174ee1748a 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -2198,7 +2198,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_late_warn_uninitialized (ctxt_); }
+  opt_pass * clone () { return new pass_late_warn_uninitialized (m_ctxt); }
   bool gate () { return gate_warn_uninitialized (); }
   unsigned int execute () { return execute_late_warn_uninitialized (); }
 
diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index 9e770cb8dbc..721c8314b4a 100644
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -1088,7 +1088,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_tail_recursion (ctxt_); }
+  opt_pass * clone () { return new pass_tail_recursion (m_ctxt); }
   bool gate () { return gate_tail_calls (); }
   unsigned int execute () { return execute_tail_recursion (); }
 
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index 07158fb05e9..df2f894e0f4 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -1523,7 +1523,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_lower_vector_ssa (ctxt_); }
+  opt_pass * clone () { return new pass_lower_vector_ssa (m_ctxt); }
   unsigned int execute () { return expand_vector_operations (); }
 
 }; // class pass_lower_vector_ssa
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index caf3d55dc49..52d90080c19 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -9670,7 +9670,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_vrp (ctxt_); }
+  opt_pass * clone () { return new pass_vrp (m_ctxt); }
   bool gate () { return gate_vrp (); }
   unsigned int execute () { return execute_vrp (); }
 
diff --git a/gcc/tsan.c b/gcc/tsan.c
index 363f1608513..3619f25045d 100644
--- a/gcc/tsan.c
+++ b/gcc/tsan.c
@@ -758,7 +758,7 @@ public:
   {}
 
   /* opt_pass methods: */
-  opt_pass * clone () { return new pass_tsan (ctxt_); }
+  opt_pass * clone () { return new pass_tsan (m_ctxt); }
   bool gate () { return tsan_gate (); }
   unsigned int execute () { return tsan_pass (); }