+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
{}
/* 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 (); }
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. */
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
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);
}
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. */
edge
control_dependences::get_edge (int i)
{
- return INDEX_EDGE (el, i);
+ return INDEX_EDGE (m_el, i);
}
{}
/* 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
/* 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 (); }
gcc::context::context ()
{
- passes_ = new gcc::pass_manager (this);
+ m_passes = new gcc::pass_manager (this);
}
/* 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
{}
/* 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 (); }
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);
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:
else
break;
}
- if (dom_direction_ == CDI_DOMINATORS)
+ if (m_dom_direction == CDI_DOMINATORS)
{
free (bb_postorder);
bb_postorder = NULL;
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);
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
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". */
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)
{
}
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;
}
}
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 "
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,
void
s_expr_writer::end_s_expr (void)
{
- indent_amount_--;
+ m_indent_amount--;
write_any_indent (0);
fprintf (state_file, ")");
write_new_line ();
/* class state_writer's trivial constructor. */
state_writer::state_writer ()
: s_expr_writer (),
- state_written_type_count (0)
+ m_state_written_type_count (0)
{
}
}
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:
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);
}
\f
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
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);
{
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 ();
}
}
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 ();
}
}
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:
template <typename Type> class Allocator>
inline
hash_table <Descriptor, Allocator>::iterator::iterator ()
-: slot_ (NULL), limit_ (NULL)
+: m_slot (NULL), m_limit (NULL)
{
}
inline
hash_table <Descriptor, Allocator>::iterator::iterator
(value_type **slot, value_type **limit)
-: slot_ (slot), limit_ (limit)
+: m_slot (slot), m_limit (limit)
{
}
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. */
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. */
inline typename hash_table <Descriptor, Allocator>::iterator &
hash_table <Descriptor, Allocator>::iterator::operator ++ ()
{
- ++slot_;
+ ++m_slot;
slide ();
return *this;
}
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. */
{}
/* 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 ();
}
{}
/* 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 (); }
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. */
/* 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 (); }
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.
sub (NULL),
next (NULL),
static_pass_number (0),
- ctxt_ (ctxt)
+ m_ctxt (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;
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); \
{}
/* 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
/* 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 (); }
/* 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
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
= 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;
}
}
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. */
/* 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;
bool
bit_field_mode_iterator::prefer_smaller_modes ()
{
- return (volatilep_
+ return (m_volatilep
? targetm.narrow_volatile_bitfield ()
: !SLOW_BYTE_ACCESS);
}
/* 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
{}
/* 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 (); }
{}
/* 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
{}
/* 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 (); }
/* 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
{
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. */
{}
/* 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
{}
/* 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
int static_pass_number;
protected:
- gcc::context *ctxt_;
+ gcc::context *m_ctxt;
};
/* Description of GIMPLE pass. */
{}
/* 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 (); }
{}
/* 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
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{
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);
private:
void thread_across_edge (edge);
- gimple dummy_cond_;
+ gimple m_dummy_cond;
};
/* Jump threading, redundancy elimination and const/copy propagation.
{}
/* 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 (); }
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);
/* 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);
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{
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. */
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);
}
}
}
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
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);
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. */
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. */
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);
}
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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 (); }
{}
/* 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
{}
/* 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 (); }
{}
/* 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 (); }
projects / gcc.git / commitdiff