Patchwork RFA: Use "m_foo" rather than "foo_" for member variables

login
register
mail settings
Submitter Richard Sandiford
Date Sept. 29, 2013, 9:08 a.m.
Message ID <87wqm0kna6.fsf_-_@talisman.default>
Download mbox | patch
Permalink /patch/278826/
State New
Headers show

Comments

Richard Sandiford - Sept. 29, 2013, 9:08 a.m.
Michael Matz <matz@suse.de> writes:
>Trever Saunders <tsaunders@mozilla.com> writes:
>> Richard Biener <richard.guenther@gmail.com> writes:
>> > Btw, I've come around multiple coding-styles in the past and I 
>> > definitely would prefer m_mode / m_count to mark members vs. mode_ and 
>> > count_. (and s_XXX for static members IIRC).
>>
>> I'd prefer m_/s_foo for members / static things too fwiw.
>
> Me as well.  It's still ugly, but not so unsymmetric as the trailing 
> underscore.

Well, I'm not sure how I came to be the one writing these patches,
but I suppose I prefer m_foo too.  So how about the attached?

The first patch has changes to the coding conventions.  I added
some missing spaces while there.

The second patch has the mechanical code changes.  The reason for
yesterday's mass adding of spaces was because the second patch would
have been pretty inconsistent otherwise.

Tested on x86_64-linux-gnu.

Thanks,
Richard
Richard Guenther - Sept. 30, 2013, 12:05 p.m.
On Sun, Sep 29, 2013 at 11:08 AM, Richard Sandiford
<rdsandiford@googlemail.com> wrote:
> Michael Matz <matz@suse.de> writes:
>>Trever Saunders <tsaunders@mozilla.com> writes:
>>> Richard Biener <richard.guenther@gmail.com> writes:
>>> > Btw, I've come around multiple coding-styles in the past and I
>>> > definitely would prefer m_mode / m_count to mark members vs. mode_ and
>>> > count_. (and s_XXX for static members IIRC).
>>>
>>> I'd prefer m_/s_foo for members / static things too fwiw.
>>
>> Me as well.  It's still ugly, but not so unsymmetric as the trailing
>> underscore.
>
> Well, I'm not sure how I came to be the one writing these patches,
> but I suppose I prefer m_foo too.  So how about the attached?
>
> The first patch has changes to the coding conventions.  I added
> some missing spaces while there.
>
> The second patch has the mechanical code changes.  The reason for
> yesterday's mass adding of spaces was because the second patch would
> have been pretty inconsistent otherwise.
>
> Tested on x86_64-linux-gnu.

Ok.

Thanks,
Richard.

> Thanks,
> Richard
>
>

Patch

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.

Index: gcc/basic-block.h
===================================================================
--- gcc/basic-block.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/basic-block.h	2013-09-28 09:49:21.442135998 +0100
@@ -479,7 +479,7 @@  struct edge_list
   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.  */
Index: gcc/context.h
===================================================================
--- gcc/context.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/context.h	2013-09-28 09:49:21.443136085 +0100
@@ -34,11 +34,11 @@  #define GCC_CONTEXT_H
 
   /* 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
 
Index: gcc/domwalk.h
===================================================================
--- gcc/domwalk.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/domwalk.h	2013-09-28 09:49:21.444136172 +0100
@@ -30,7 +30,7 @@  #define GCC_DOM_WALK_H
 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 @@  #define GCC_DOM_WALK_H
      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
Index: gcc/gengtype-state.c
===================================================================
--- gcc/gengtype-state.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/gengtype-state.c	2013-09-28 09:49:21.444136172 +0100
@@ -151,8 +151,8 @@  static long state_bol = 0;	/* offset of
   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 @@  static long state_bol = 0;	/* offset of
 
 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 @@  s_expr_writer::s_expr_writer ()
 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 @@  s_expr_writer::write_new_line (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
   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
 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 c
     }
   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);
 
 }
 
Index: gcc/graphite-sese-to-poly.c
===================================================================
--- gcc/graphite-sese-to-poly.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/graphite-sese-to-poly.c	2013-09-28 09:49:21.445136259 +0100
@@ -1226,21 +1226,21 @@  single_pred_cond_non_loop_exit (basic_bl
   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 (ba
   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 (ba
     {
       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 (ba
 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 ();
     }
 }
 
Index: gcc/hash-table.h
===================================================================
--- gcc/hash-table.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/hash-table.h	2013-09-28 09:49:21.445136259 +0100
@@ -419,8 +419,8 @@  struct hash_table_control
     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 @@  hash_table <Descriptor, Allocator>::trav
 	  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 @@  hash_table <Descriptor, Allocator>::iter
 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 @@  hash_table <Descriptor, Allocator>::iter
 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 @@  hash_table <Descriptor, Allocator>::iter
 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 @@  hash_table <Descriptor, Allocator>::iter
 inline typename hash_table <Descriptor, Allocator>::iterator &
 hash_table <Descriptor, Allocator>::iterator::operator ++ ()
 {
-  ++slot_;
+  ++m_slot;
   slide ();
   return *this;
 }
@@ -1021,7 +1021,7 @@  hash_table <Descriptor, Allocator>::iter
 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.  */
Index: gcc/machmode.h
===================================================================
--- gcc/machmode.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/machmode.h	2013-09-28 09:49:21.446136345 +0100
@@ -269,16 +269,16 @@  extern enum machine_mode mode_for_vector
   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.  */
Index: gcc/pass_manager.h
===================================================================
--- gcc/pass_manager.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/pass_manager.h	2013-09-28 09:49:21.446136345 +0100
@@ -97,7 +97,7 @@  enum pass_list
   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.
Index: gcc/tree-into-ssa.c
===================================================================
--- gcc/tree-into-ssa.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-into-ssa.c	2013-09-28 09:49:21.451136779 +0100
@@ -2235,17 +2235,17 @@  rewrite_blocks (basic_block entry, enum
   /* 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
 {
   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.  */
Index: gcc/tree-pass.h
===================================================================
--- gcc/tree-pass.h	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-pass.h	2013-09-28 09:49:21.452136866 +0100
@@ -115,7 +115,7 @@  struct pass_data
   int static_pass_number;
 
 protected:
-  gcc::context *ctxt_;
+  gcc::context *m_ctxt;
 };
 
 /* Description of GIMPLE pass.  */
Index: gcc/tree-ssa-dom.c
===================================================================
--- gcc/tree-ssa-dom.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-dom.c	2013-09-28 09:49:21.454137039 +0100
@@ -775,7 +775,7 @@  free_all_edge_infos (void)
 {
 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 @@  free_all_edge_infos (void)
 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 @@  const pass_data pass_data_dominator =
   {}
 
   /* 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 (
 
   /* 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 @@  const pass_data pass_data_phi_only_cprop
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-phiopt.c
===================================================================
--- gcc/tree-ssa-phiopt.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-phiopt.c	2013-09-28 09:49:21.455137126 +0100
@@ -1379,13 +1379,13 @@  nonfreeing_call_p (gimple call)
 {
 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_child
 	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 @@  const pass_data pass_data_phiopt =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-uncprop.c
===================================================================
--- gcc/tree-ssa-uncprop.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-uncprop.c	2013-09-28 09:49:21.456137213 +0100
@@ -360,11 +360,11 @@  record_equiv (tree value, tree equivalen
   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 @@  record_equiv (tree value, tree equivalen
 
 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 @@  tree_ssa_uncprop (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
 	  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 @@  const pass_data pass_data_uncprop =
   {}
 
   /* 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 (); }
 
Index: gcc/asan.c
===================================================================
--- gcc/asan.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/asan.c	2013-09-28 09:49:21.442135998 +0100
@@ -2273,7 +2273,7 @@  const pass_data pass_data_asan =
   {}
 
   /* 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 (); }
 
Index: gcc/cfganal.c
===================================================================
--- gcc/cfganal.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/cfganal.c	2013-09-28 09:49:21.442135998 +0100
@@ -389,18 +389,18 @@  control_dependences::find_control_depend
   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_depend
    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_dependence
   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
 edge
 control_dependences::get_edge (int i)
 {
-  return INDEX_EDGE (el, i);
+  return INDEX_EDGE (m_el, i);
 }
 
 
Index: gcc/cgraphbuild.c
===================================================================
--- gcc/cgraphbuild.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/cgraphbuild.c	2013-09-28 09:49:21.443136085 +0100
@@ -530,7 +530,7 @@  const pass_data pass_data_rebuild_cgraph
   {}
 
   /* 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 @@  const pass_data pass_data_remove_cgraph_
 
   /* 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 (); }
 
Index: gcc/context.c
===================================================================
--- gcc/context.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/context.c	2013-09-28 09:49:21.443136085 +0100
@@ -29,5 +29,5 @@  Software Foundation; either version 3, o
 
 gcc::context::context ()
 {
-  passes_ = new gcc::pass_manager (this);
+  m_passes = new gcc::pass_manager (this);
 }
Index: gcc/cprop.c
===================================================================
--- gcc/cprop.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/cprop.c	2013-09-28 09:49:21.443136085 +0100
@@ -1940,7 +1940,7 @@  const pass_data pass_data_rtl_cprop =
   {}
 
   /* 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 (); }
 
Index: gcc/domwalk.c
===================================================================
--- gcc/domwalk.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/domwalk.c	2013-09-28 09:49:21.443136085 +0100
@@ -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;
Index: gcc/ipa-inline-analysis.c
===================================================================
--- gcc/ipa-inline-analysis.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/ipa-inline-analysis.c	2013-09-28 09:49:21.445136259 +0100
@@ -2744,7 +2744,7 @@  const pass_data pass_data_inline_paramet
   {}
 
   /* 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 ();
   }
Index: gcc/ipa-pure-const.c
===================================================================
--- gcc/ipa-pure-const.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/ipa-pure-const.c	2013-09-28 09:49:21.446136345 +0100
@@ -1709,7 +1709,7 @@  const pass_data pass_data_local_pure_con
   {}
 
   /* 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 (); }
 
Index: gcc/mode-switching.c
===================================================================
--- gcc/mode-switching.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/mode-switching.c	2013-09-28 09:49:21.446136345 +0100
@@ -811,7 +811,7 @@  const pass_data pass_data_mode_switching
   /* 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 (); }
 
Index: gcc/passes.c
===================================================================
--- gcc/passes.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/passes.c	2013-09-28 09:49:21.447136432 +0100
@@ -112,7 +112,7 @@  opt_pass::opt_pass (const pass_data &dat
     sub (NULL),
     next (NULL),
     static_pass_number (0),
-    ctxt_ (ctxt)
+    m_ctxt (ctxt)
 {
 }
 
@@ -1488,7 +1488,7 @@  pass_manager::pass_manager (context *ctx
 : 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 @@  #define NEXT_PASS(PASS, NUM) \
   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);                 \
Index: gcc/predict.c
===================================================================
--- gcc/predict.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/predict.c	2013-09-28 09:49:21.447136432 +0100
@@ -3000,7 +3000,7 @@  const pass_data pass_data_strip_predict_
   {}
 
   /* 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
Index: gcc/recog.c
===================================================================
--- gcc/recog.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/recog.c	2013-09-28 09:49:21.448136519 +0100
@@ -3808,7 +3808,7 @@  const pass_data pass_data_peephole2 =
   /* 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 @@  const pass_data pass_data_split_all_insn
   /* 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
Index: gcc/stor-layout.c
===================================================================
--- gcc/stor-layout.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/stor-layout.c	2013-09-28 09:49:21.448136519 +0100
@@ -2627,12 +2627,12 @@  fixup_unsigned_type (tree type)
 			   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 @@  fixup_unsigned_type (tree type)
 	= 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 @@  fixup_unsigned_type (tree type)
 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
 
       /* 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
 bool
 bit_field_mode_iterator::prefer_smaller_modes ()
 {
-  return (volatilep_
+  return (m_volatilep
 	  ? targetm.narrow_volatile_bitfield ()
 	  : !SLOW_BYTE_ACCESS);
 }
Index: gcc/tree-cfg.c
===================================================================
--- gcc/tree-cfg.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-cfg.c	2013-09-28 09:49:21.450136692 +0100
@@ -7964,7 +7964,7 @@  const pass_data pass_data_split_crit_edg
   /* 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
Index: gcc/tree-cfgcleanup.c
===================================================================
--- gcc/tree-cfgcleanup.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-cfgcleanup.c	2013-09-28 09:49:21.450136692 +0100
@@ -1014,7 +1014,7 @@  const pass_data pass_data_merge_phi =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-complex.c
===================================================================
--- gcc/tree-complex.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-complex.c	2013-09-28 09:49:21.450136692 +0100
@@ -1662,7 +1662,7 @@  const pass_data pass_data_lower_complex
   {}
 
   /* 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
Index: gcc/tree-eh.c
===================================================================
--- gcc/tree-eh.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-eh.c	2013-09-28 09:49:21.451136779 +0100
@@ -4541,7 +4541,7 @@  const pass_data pass_data_cleanup_eh =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-object-size.c
===================================================================
--- gcc/tree-object-size.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-object-size.c	2013-09-28 09:49:21.451136779 +0100
@@ -1288,7 +1288,7 @@  const pass_data pass_data_object_sizes =
   {}
 
   /* 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
Index: gcc/tree-optimize.c
===================================================================
--- gcc/tree-optimize.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-optimize.c	2013-09-28 09:49:21.452136866 +0100
@@ -255,7 +255,7 @@  const pass_data pass_data_fixup_cfg =
   {}
 
   /* 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
Index: gcc/tree-ssa-ccp.c
===================================================================
--- gcc/tree-ssa-ccp.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-ccp.c	2013-09-28 09:49:21.452136866 +0100
@@ -2171,7 +2171,7 @@  const pass_data pass_data_ccp =
   {}
 
   /* 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 @@  const pass_data pass_data_fold_builtins
   {}
 
   /* 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
Index: gcc/tree-ssa-copy.c
===================================================================
--- gcc/tree-ssa-copy.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-copy.c	2013-09-28 09:49:21.453136953 +0100
@@ -863,7 +863,7 @@  const pass_data pass_data_copy_prop =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-copyrename.c
===================================================================
--- gcc/tree-ssa-copyrename.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-copyrename.c	2013-09-28 09:49:21.453136953 +0100
@@ -460,7 +460,7 @@  const pass_data pass_data_rename_ssa_cop
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-dce.c
===================================================================
--- gcc/tree-ssa-dce.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-dce.c	2013-09-28 09:49:21.453136953 +0100
@@ -1565,7 +1565,7 @@  const pass_data pass_data_dce =
   {}
 
   /* 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 @@  const pass_data pass_data_dce_loop =
   {}
 
   /* 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 @@  const pass_data pass_data_cd_dce =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-dse.c
===================================================================
--- gcc/tree-ssa-dse.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-dse.c	2013-09-28 09:49:21.454137039 +0100
@@ -380,7 +380,7 @@  const pass_data pass_data_dse =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-forwprop.c
===================================================================
--- gcc/tree-ssa-forwprop.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-forwprop.c	2013-09-28 09:49:21.454137039 +0100
@@ -3565,7 +3565,7 @@  const pass_data pass_data_forwprop =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-loop.c
===================================================================
--- gcc/tree-ssa-loop.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-loop.c	2013-09-28 09:49:21.454137039 +0100
@@ -176,7 +176,7 @@  const pass_data pass_data_lim =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-pre.c
===================================================================
--- gcc/tree-ssa-pre.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-pre.c	2013-09-28 09:49:21.455137126 +0100
@@ -4865,7 +4865,7 @@  const pass_data pass_data_fre =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-reassoc.c
===================================================================
--- gcc/tree-ssa-reassoc.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-reassoc.c	2013-09-28 09:49:21.456137213 +0100
@@ -4485,7 +4485,7 @@  const pass_data pass_data_reassoc =
   {}
 
   /* 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 (); }
 
Index: gcc/tree-ssa-uninit.c
===================================================================
--- gcc/tree-ssa-uninit.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-ssa-uninit.c	2013-09-28 09:49:21.457137300 +0100
@@ -2198,7 +2198,7 @@  const pass_data pass_data_late_warn_unin
   {}
 
   /* 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 (); }
 
Index: gcc/tree-tailcall.c
===================================================================
--- gcc/tree-tailcall.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-tailcall.c	2013-09-28 09:49:21.457137300 +0100
@@ -1088,7 +1088,7 @@  const pass_data pass_data_tail_recursion
   {}
 
   /* 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 (); }
 
Index: gcc/tree-vect-generic.c
===================================================================
--- gcc/tree-vect-generic.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-vect-generic.c	2013-09-28 09:49:21.457137300 +0100
@@ -1523,7 +1523,7 @@  const pass_data pass_data_lower_vector_s
   {}
 
   /* 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
Index: gcc/tree-vrp.c
===================================================================
--- gcc/tree-vrp.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tree-vrp.c	2013-09-28 09:49:21.458137386 +0100
@@ -9670,7 +9670,7 @@  const pass_data pass_data_vrp =
   {}
 
   /* 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 (); }
 
Index: gcc/tsan.c
===================================================================
--- gcc/tsan.c	2013-09-28 09:48:04.539149352 +0100
+++ gcc/tsan.c	2013-09-28 09:49:21.459137473 +0100
@@ -758,7 +758,7 @@  const pass_data pass_data_tsan =
   {}
 
   /* 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 (); }