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

47 files changed, 224 insertions, 160 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d125ced..e3a5c82 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 688c231..c037ebf 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 b68cb45..acb5ea8 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 c4ea7dd..56853b9 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 4cf562e..1b73a14 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 6bd25f0..09e1f89 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 ed6a24a..4aab6de 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 9d6cb46..358fca9 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 bffa4aa..4816b4c 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 b33d70e..43c1574 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 a019aaf..96ecc7c 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 3949098..2d88206 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 6d01188..5f80efb 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 00a21d9..7ca09ad 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 bc0a17b..7e44d51 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 981ee92..da0923a 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 23ed63b..483566b 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 cca6a35..77d78eb 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 e64281e..e7b7b9a 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 2472fca..4815e75 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 f64753a..a3ca98c 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 0299836..6584b57 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 f0dd2bc..b72ac61 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 37d6d03..cd4307e 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 0f26ab6..7d9b696 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 e8462cf..1ad5baf 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 2fe710e..18b00a8 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 9721457..0bdbc48 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 6663146..445bd7c 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 3400329..e72fe9a 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 849e9e9..fe21c07 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 a20fc97..5ab5389 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 f4395e4..d8660c5 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 c132baf..c20a13a 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 495b6b8..7013f43 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 45c8b2f..700824c 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 ee8240e..8807db1 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 947f4d4..3952029 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 d9dbed3..c39419f 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 243f37e..bd13476 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 62c46a1..cbf3a2d 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 0bff196..28ff546 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 044efb3..0174ee1 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 9e770cb..721c8314b 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 07158fb..df2f894 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 caf3d55..52d9008 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 363f160..3619f25 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 (); }