On Wed, 17 Sep 2014, Jan Hubicka wrote: > Hi, > this patch renames types reported by Wodr during LTO bootstrap. > > Bootrapping/regtesting in progress, OK if it passes? > > Honza > > * tree-ssa-ccp.c (prop_value_d): Rename to ... > (ccp_prop_value_t): ... this one to avoid ODR violation; update uses. > * ipa-prop.c (struct type_change_info): Rename to ... > (prop_type_change_infoprop_type_change_info): ... this; update uses.
Seems a bit excessive ;) Ok. Thanks, Richard. > * ggc-page.c (globals): Rename to ... > (static struct ggc_globals): ... this; update uses. > * tree-ssa-loop-im.c (mem_ref): Rename to ... > (im_mem_ref): ... this; update uses. > * ggc-common.c (loc_descriptor): Rename to ... > (ggc_loc_descriptor): ... this; update uses. > * lra-eliminations.c (elim_table): Rename to ... > (lra_elim_table): ... this; update uses. > * bitmap.c (output_info): Rename to ... > (bitmap_output_info): ... this; update uses. > * gcse.c (expr): Rename to ... > (gcse_expr) ... this; update uses. > (occr): Rename to ... > (gcse_occr): .. this; update uses. > * tree-ssa-copy.c (prop_value_d): Rename to ... > (prop_value_t): ... this. > * predict.c (block_info_def): Rename to ... > (block_info): ... this; update uses. > (edge_info_def): Rename to ... > (edge_info): ... this; update uses. > * profile.c (bb_info): Rename to ... > (bb_profile_info): ... this; update uses. > * alloc-pool.c (output_info): Rename to ... > (pool_output_info): ... this; update uses. > > Index: tree-ssa-ccp.c > =================================================================== > --- tree-ssa-ccp.c (revision 215328) > +++ tree-ssa-ccp.c (working copy) > @@ -166,7 +166,7 @@ typedef enum > VARYING > } ccp_lattice_t; > > -struct prop_value_d { > +struct ccp_prop_value_t { > /* Lattice value. */ > ccp_lattice_t lattice_val; > > @@ -180,24 +180,22 @@ struct prop_value_d { > widest_int mask; > }; > > -typedef struct prop_value_d prop_value_t; > - > /* Array of propagated constant values. After propagation, > CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If > the constant is held in an SSA name representing a memory store > (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual > memory reference used to store (i.e., the LHS of the assignment > doing the store). */ > -static prop_value_t *const_val; > +static ccp_prop_value_t *const_val; > static unsigned n_const_val; > > -static void canonicalize_value (prop_value_t *); > +static void canonicalize_value (ccp_prop_value_t *); > static bool ccp_fold_stmt (gimple_stmt_iterator *); > > /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */ > > static void > -dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val) > +dump_lattice_value (FILE *outf, const char *prefix, ccp_prop_value_t val) > { > switch (val.lattice_val) > { > @@ -236,10 +234,10 @@ dump_lattice_value (FILE *outf, const ch > > /* Print lattice value VAL to stderr. */ > > -void debug_lattice_value (prop_value_t val); > +void debug_lattice_value (ccp_prop_value_t val); > > DEBUG_FUNCTION void > -debug_lattice_value (prop_value_t val) > +debug_lattice_value (ccp_prop_value_t val) > { > dump_lattice_value (stderr, "", val); > fprintf (stderr, "\n"); > @@ -272,10 +270,10 @@ extend_mask (const wide_int &nonzero_bit > 4- Initial values of variables that are not GIMPLE registers are > considered VARYING. */ > > -static prop_value_t > +static ccp_prop_value_t > get_default_value (tree var) > { > - prop_value_t val = { UNINITIALIZED, NULL_TREE, 0 }; > + ccp_prop_value_t val = { UNINITIALIZED, NULL_TREE, 0 }; > gimple stmt; > > stmt = SSA_NAME_DEF_STMT (var); > @@ -343,10 +341,10 @@ get_default_value (tree var) > > /* Get the constant value associated with variable VAR. */ > > -static inline prop_value_t * > +static inline ccp_prop_value_t * > get_value (tree var) > { > - prop_value_t *val; > + ccp_prop_value_t *val; > > if (const_val == NULL > || SSA_NAME_VERSION (var) >= n_const_val) > @@ -366,7 +364,7 @@ get_value (tree var) > static inline tree > get_constant_value (tree var) > { > - prop_value_t *val; > + ccp_prop_value_t *val; > if (TREE_CODE (var) != SSA_NAME) > { > if (is_gimple_min_invariant (var)) > @@ -387,7 +385,7 @@ get_constant_value (tree var) > static inline void > set_value_varying (tree var) > { > - prop_value_t *val = &const_val[SSA_NAME_VERSION (var)]; > + ccp_prop_value_t *val = &const_val[SSA_NAME_VERSION (var)]; > > val->lattice_val = VARYING; > val->value = NULL_TREE; > @@ -413,7 +411,7 @@ set_value_varying (tree var) > For other constants, make sure to drop TREE_OVERFLOW. */ > > static void > -canonicalize_value (prop_value_t *val) > +canonicalize_value (ccp_prop_value_t *val) > { > enum machine_mode mode; > tree type; > @@ -451,7 +449,7 @@ canonicalize_value (prop_value_t *val) > /* Return whether the lattice transition is valid. */ > > static bool > -valid_lattice_transition (prop_value_t old_val, prop_value_t new_val) > +valid_lattice_transition (ccp_prop_value_t old_val, ccp_prop_value_t new_val) > { > /* Lattice transitions must always be monotonically increasing in > value. */ > @@ -486,10 +484,10 @@ valid_lattice_transition (prop_value_t o > value is different from VAR's previous value. */ > > static bool > -set_lattice_value (tree var, prop_value_t new_val) > +set_lattice_value (tree var, ccp_prop_value_t new_val) > { > /* We can deal with old UNINITIALIZED values just fine here. */ > - prop_value_t *old_val = &const_val[SSA_NAME_VERSION (var)]; > + ccp_prop_value_t *old_val = &const_val[SSA_NAME_VERSION (var)]; > > canonicalize_value (&new_val); > > @@ -534,8 +532,8 @@ set_lattice_value (tree var, prop_value_ > return false; > } > > -static prop_value_t get_value_for_expr (tree, bool); > -static prop_value_t bit_value_binop (enum tree_code, tree, tree, tree); > +static ccp_prop_value_t get_value_for_expr (tree, bool); > +static ccp_prop_value_t bit_value_binop (enum tree_code, tree, tree, tree); > static void bit_value_binop_1 (enum tree_code, tree, widest_int *, > widest_int *, > tree, const widest_int &, const widest_int &, > tree, const widest_int &, const widest_int &); > @@ -544,7 +542,7 @@ static void bit_value_binop_1 (enum tree > from VAL. */ > > static widest_int > -value_to_wide_int (prop_value_t val) > +value_to_wide_int (ccp_prop_value_t val) > { > if (val.value > && TREE_CODE (val.value) == INTEGER_CST) > @@ -556,11 +554,11 @@ value_to_wide_int (prop_value_t val) > /* Return the value for the address expression EXPR based on alignment > information. */ > > -static prop_value_t > +static ccp_prop_value_t > get_value_from_alignment (tree expr) > { > tree type = TREE_TYPE (expr); > - prop_value_t val; > + ccp_prop_value_t val; > unsigned HOST_WIDE_INT bitpos; > unsigned int align; > > @@ -583,10 +581,10 @@ get_value_from_alignment (tree expr) > return constant bits extracted from alignment information for > invariant addresses. */ > > -static prop_value_t > +static ccp_prop_value_t > get_value_for_expr (tree expr, bool for_bits_p) > { > - prop_value_t val; > + ccp_prop_value_t val; > > if (TREE_CODE (expr) == SSA_NAME) > { > @@ -654,7 +652,7 @@ likely_value (gimple stmt) > all_undefined_operands = true; > FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE) > { > - prop_value_t *val = get_value (use); > + ccp_prop_value_t *val = get_value (use); > > if (val->lattice_val == UNDEFINED) > has_undefined_operand = true; > @@ -792,7 +790,7 @@ ccp_initialize (void) > basic_block bb; > > n_const_val = num_ssa_names; > - const_val = XCNEWVEC (prop_value_t, n_const_val); > + const_val = XCNEWVEC (ccp_prop_value_t, n_const_val); > > /* Initialize simulation flags for PHI nodes and statements. */ > FOR_EACH_BB_FN (bb, cfun) > @@ -884,7 +882,7 @@ ccp_finalize (void) > for (i = 1; i < num_ssa_names; ++i) > { > tree name = ssa_name (i); > - prop_value_t *val; > + ccp_prop_value_t *val; > unsigned int tem, align; > > if (!name > @@ -941,7 +939,7 @@ ccp_finalize (void) > */ > > static void > -ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2) > +ccp_lattice_meet (ccp_prop_value_t *val1, ccp_prop_value_t *val2) > { > if (val1->lattice_val == UNDEFINED) > { > @@ -997,7 +995,7 @@ ccp_lattice_meet (prop_value_t *val1, pr > { > /* When not equal addresses are involved try meeting for > alignment. */ > - prop_value_t tem = *val2; > + ccp_prop_value_t tem = *val2; > if (TREE_CODE (val1->value) == ADDR_EXPR) > *val1 = get_value_for_expr (val1->value, true); > if (TREE_CODE (val2->value) == ADDR_EXPR) > @@ -1023,7 +1021,7 @@ static enum ssa_prop_result > ccp_visit_phi_node (gimple phi) > { > unsigned i; > - prop_value_t *old_val, new_val; > + ccp_prop_value_t *old_val, new_val; > > if (dump_file && (dump_flags & TDF_DETAILS)) > { > @@ -1069,7 +1067,7 @@ ccp_visit_phi_node (gimple phi) > if (e->flags & EDGE_EXECUTABLE) > { > tree arg = gimple_phi_arg (phi, i)->def; > - prop_value_t arg_val = get_value_for_expr (arg, false); > + ccp_prop_value_t arg_val = get_value_for_expr (arg, false); > > ccp_lattice_meet (&new_val, &arg_val); > > @@ -1449,12 +1447,12 @@ bit_value_binop_1 (enum tree_code code, > /* Return the propagation value when applying the operation CODE to > the value RHS yielding type TYPE. */ > > -static prop_value_t > +static ccp_prop_value_t > bit_value_unop (enum tree_code code, tree type, tree rhs) > { > - prop_value_t rval = get_value_for_expr (rhs, true); > + ccp_prop_value_t rval = get_value_for_expr (rhs, true); > widest_int value, mask; > - prop_value_t val; > + ccp_prop_value_t val; > > if (rval.lattice_val == UNDEFINED) > return rval; > @@ -1483,13 +1481,13 @@ bit_value_unop (enum tree_code code, tre > /* Return the propagation value when applying the operation CODE to > the values RHS1 and RHS2 yielding type TYPE. */ > > -static prop_value_t > +static ccp_prop_value_t > bit_value_binop (enum tree_code code, tree type, tree rhs1, tree rhs2) > { > - prop_value_t r1val = get_value_for_expr (rhs1, true); > - prop_value_t r2val = get_value_for_expr (rhs2, true); > + ccp_prop_value_t r1val = get_value_for_expr (rhs1, true); > + ccp_prop_value_t r2val = get_value_for_expr (rhs2, true); > widest_int value, mask; > - prop_value_t val; > + ccp_prop_value_t val; > > if (r1val.lattice_val == UNDEFINED > || r2val.lattice_val == UNDEFINED) > @@ -1532,15 +1530,15 @@ bit_value_binop (enum tree_code code, tr > is false, for alloc_aligned attribute ATTR is non-NULL and > ALLOC_ALIGNED is true. */ > > -static prop_value_t > -bit_value_assume_aligned (gimple stmt, tree attr, prop_value_t ptrval, > +static ccp_prop_value_t > +bit_value_assume_aligned (gimple stmt, tree attr, ccp_prop_value_t ptrval, > bool alloc_aligned) > { > tree align, misalign = NULL_TREE, type; > unsigned HOST_WIDE_INT aligni, misaligni = 0; > - prop_value_t alignval; > + ccp_prop_value_t alignval; > widest_int value, mask; > - prop_value_t val; > + ccp_prop_value_t val; > > if (attr == NULL_TREE) > { > @@ -1632,10 +1630,10 @@ bit_value_assume_aligned (gimple stmt, t > /* Evaluate statement STMT. > Valid only for assignments, calls, conditionals, and switches. */ > > -static prop_value_t > +static ccp_prop_value_t > evaluate_stmt (gimple stmt) > { > - prop_value_t val; > + ccp_prop_value_t val; > tree simplified = NULL_TREE; > ccp_lattice_t likelyvalue = likely_value (stmt); > bool is_constant = false; > @@ -2062,7 +2060,7 @@ ccp_fold_stmt (gimple_stmt_iterator *gsi > { > case GIMPLE_COND: > { > - prop_value_t val; > + ccp_prop_value_t val; > /* Statement evaluation will handle type mismatches in constants > more gracefully than the final propagation. This allows us to > fold more conditionals here. */ > @@ -2197,7 +2195,7 @@ ccp_fold_stmt (gimple_stmt_iterator *gsi > static enum ssa_prop_result > visit_assignment (gimple stmt, tree *output_p) > { > - prop_value_t val; > + ccp_prop_value_t val; > enum ssa_prop_result retval; > > tree lhs = gimple_get_lhs (stmt); > @@ -2242,7 +2240,7 @@ visit_assignment (gimple stmt, tree *out > static enum ssa_prop_result > visit_cond_stmt (gimple stmt, edge *taken_edge_p) > { > - prop_value_t val; > + ccp_prop_value_t val; > basic_block block; > > block = gimple_bb (stmt); > @@ -2320,7 +2318,7 @@ ccp_visit_stmt (gimple stmt, edge *taken > Mark them VARYING. */ > FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS) > { > - prop_value_t v = { VARYING, NULL_TREE, -1 }; > + ccp_prop_value_t v = { VARYING, NULL_TREE, -1 }; > set_lattice_value (def, v); > } > > Index: ipa-prop.c > =================================================================== > --- ipa-prop.c (revision 215328) > +++ ipa-prop.c (working copy) > @@ -592,7 +592,7 @@ ipa_get_bb_info (struct func_body_info * > /* Structure to be passed in between detect_type_change and > check_stmt_for_type_change. */ > > -struct type_change_info > +struct prop_type_change_info > { > /* Offset into the object where there is the virtual method pointer we are > looking for. */ > @@ -680,7 +680,7 @@ stmt_may_be_vtbl_ptr_store (gimple stmt) > identified, return the type. Otherwise return NULL_TREE. */ > > static tree > -extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci) > +extr_type_from_vtbl_ptr_store (gimple stmt, struct prop_type_change_info > *tci) > { > HOST_WIDE_INT offset, size, max_size; > tree lhs, rhs, base, binfo; > @@ -726,13 +726,13 @@ extr_type_from_vtbl_ptr_store (gimple st > detect_type_change to check whether a particular statement may modify > the virtual table pointer, and if possible also determine the new type of > the (sub-)object. It stores its result into DATA, which points to a > - type_change_info structure. */ > + prop_type_change_info structure. */ > > static bool > check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void > *data) > { > gimple stmt = SSA_NAME_DEF_STMT (vdef); > - struct type_change_info *tci = (struct type_change_info *) data; > + struct prop_type_change_info *tci = (struct prop_type_change_info *) data; > > if (stmt_may_be_vtbl_ptr_store (stmt)) > { > @@ -830,7 +830,7 @@ detect_type_change_from_memory_writes (t > gimple call, struct ipa_jump_func *jfunc, > HOST_WIDE_INT offset) > { > - struct type_change_info tci; > + struct prop_type_change_info tci; > ao_ref ao; > bool entry_reached = false; > > Index: ggc-page.c > =================================================================== > --- ggc-page.c (revision 215328) > +++ ggc-page.c (working copy) > @@ -378,7 +378,7 @@ struct free_object > #endif > > /* The rest of the global variables. */ > -static struct globals > +static struct ggc_globals > { > /* The Nth element in this array is a page with objects of size 2^N. > If there are any pages with free objects, they will be at the > Index: tree-ssa-loop-im.c > =================================================================== > --- tree-ssa-loop-im.c (revision 215328) > +++ tree-ssa-loop-im.c (working copy) > @@ -116,7 +116,7 @@ typedef struct mem_ref_loc > > /* Description of a memory reference. */ > > -typedef struct mem_ref > +typedef struct im_mem_ref > { > unsigned id; /* ID assigned to the memory reference > (its index in memory_accesses.refs_list) */ > @@ -153,15 +153,15 @@ typedef struct mem_ref > > /* Mem_ref hashtable helpers. */ > > -struct mem_ref_hasher : typed_noop_remove <mem_ref> > +struct mem_ref_hasher : typed_noop_remove <im_mem_ref> > { > - typedef mem_ref value_type; > + typedef im_mem_ref value_type; > typedef tree_node compare_type; > static inline hashval_t hash (const value_type *); > static inline bool equal (const value_type *, const compare_type *); > }; > > -/* A hash function for struct mem_ref object OBJ. */ > +/* A hash function for struct im_mem_ref object OBJ. */ > > inline hashval_t > mem_ref_hasher::hash (const value_type *mem) > @@ -169,7 +169,7 @@ mem_ref_hasher::hash (const value_type * > return mem->hash; > } > > -/* An equality function for struct mem_ref object MEM1 with > +/* An equality function for struct im_mem_ref object MEM1 with > memory reference OBJ2. */ > > inline bool > @@ -1395,7 +1395,7 @@ force_move_till (tree ref, tree *index, > /* A function to free the mem_ref object OBJ. */ > > static void > -memref_free (struct mem_ref *mem) > +memref_free (struct im_mem_ref *mem) > { > mem->accesses_in_loop.release (); > } > @@ -1406,7 +1406,7 @@ memref_free (struct mem_ref *mem) > static mem_ref_p > mem_ref_alloc (tree mem, unsigned hash, unsigned id) > { > - mem_ref_p ref = XOBNEW (&mem_ref_obstack, struct mem_ref); > + mem_ref_p ref = XOBNEW (&mem_ref_obstack, struct im_mem_ref); > ao_ref_init (&ref->mem, mem); > ref->id = id; > ref->hash = hash; > @@ -1461,7 +1461,7 @@ gather_mem_refs_stmt (struct loop *loop, > { > tree *mem = NULL; > hashval_t hash; > - mem_ref **slot; > + im_mem_ref **slot; > mem_ref_p ref; > bool is_stored; > unsigned id; > @@ -1578,7 +1578,7 @@ analyze_memory_references (void) > > /* Sort the location list of gathered memory references after their > loop postorder number. */ > - mem_ref *ref; > + im_mem_ref *ref; > FOR_EACH_VEC_ELT (memory_accesses.refs_list, i, ref) > ref->accesses_in_loop.qsort (sort_locs_in_loop_postorder_cmp); > > Index: ggc-common.c > =================================================================== > --- ggc-common.c (revision 215328) > +++ ggc-common.c (working copy) > @@ -904,7 +904,7 @@ init_ggc_heuristics (void) > } > > /* Datastructure used to store per-call-site statistics. */ > -struct loc_descriptor > +struct ggc_loc_descriptor > { > const char *file; > int line; > @@ -918,42 +918,42 @@ struct loc_descriptor > > /* Hash table helper. */ > > -struct loc_desc_hasher : typed_noop_remove <loc_descriptor> > +struct ggc_loc_desc_hasher : typed_noop_remove <ggc_loc_descriptor> > { > - typedef loc_descriptor value_type; > - typedef loc_descriptor compare_type; > + typedef ggc_loc_descriptor value_type; > + typedef ggc_loc_descriptor compare_type; > static inline hashval_t hash (const value_type *); > static inline bool equal (const value_type *, const compare_type *); > }; > > inline hashval_t > -loc_desc_hasher::hash (const value_type *d) > +ggc_loc_desc_hasher::hash (const value_type *d) > { > return htab_hash_pointer (d->function) | d->line; > } > > inline bool > -loc_desc_hasher::equal (const value_type *d, const compare_type *d2) > +ggc_loc_desc_hasher::equal (const value_type *d, const compare_type *d2) > { > return (d->file == d2->file && d->line == d2->line > && d->function == d2->function); > } > > /* Hashtable used for statistics. */ > -static hash_table<loc_desc_hasher> *loc_hash; > +static hash_table<ggc_loc_desc_hasher> *loc_hash; > > -struct ptr_hash_entry > +struct ggc_ptr_hash_entry > { > void *ptr; > - struct loc_descriptor *loc; > + struct ggc_loc_descriptor *loc; > size_t size; > }; > > /* Helper for ptr_hash table. */ > > -struct ptr_hash_hasher : typed_noop_remove <ptr_hash_entry> > +struct ptr_hash_hasher : typed_noop_remove <ggc_ptr_hash_entry> > { > - typedef ptr_hash_entry value_type; > + typedef ggc_ptr_hash_entry value_type; > typedef void compare_type; > static inline hashval_t hash (const value_type *); > static inline bool equal (const value_type *, const compare_type *); > @@ -975,22 +975,22 @@ ptr_hash_hasher::equal (const value_type > static hash_table<ptr_hash_hasher> *ptr_hash; > > /* Return descriptor for given call site, create new one if needed. */ > -static struct loc_descriptor * > +static struct ggc_loc_descriptor * > make_loc_descriptor (const char *name, int line, const char *function) > { > - struct loc_descriptor loc; > - struct loc_descriptor **slot; > + struct ggc_loc_descriptor loc; > + struct ggc_loc_descriptor **slot; > > loc.file = name; > loc.line = line; > loc.function = function; > if (!loc_hash) > - loc_hash = new hash_table<loc_desc_hasher> (10); > + loc_hash = new hash_table<ggc_loc_desc_hasher> (10); > > slot = loc_hash->find_slot (&loc, INSERT); > if (*slot) > return *slot; > - *slot = XCNEW (struct loc_descriptor); > + *slot = XCNEW (struct ggc_loc_descriptor); > (*slot)->file = name; > (*slot)->line = line; > (*slot)->function = function; > @@ -1002,9 +1002,9 @@ void > ggc_record_overhead (size_t allocated, size_t overhead, void *ptr, > const char *name, int line, const char *function) > { > - struct loc_descriptor *loc = make_loc_descriptor (name, line, function); > - struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry); > - ptr_hash_entry **slot; > + struct ggc_loc_descriptor *loc = make_loc_descriptor (name, line, > function); > + struct ggc_ptr_hash_entry *p = XNEW (struct ggc_ptr_hash_entry); > + ggc_ptr_hash_entry **slot; > > p->ptr = ptr; > p->loc = loc; > @@ -1023,9 +1023,9 @@ ggc_record_overhead (size_t allocated, s > /* Helper function for prune_overhead_list. See if SLOT is still marked and > remove it from hashtable if it is not. */ > int > -ggc_prune_ptr (ptr_hash_entry **slot, void *b ATTRIBUTE_UNUSED) > +ggc_prune_ptr (ggc_ptr_hash_entry **slot, void *b ATTRIBUTE_UNUSED) > { > - struct ptr_hash_entry *p = *slot; > + struct ggc_ptr_hash_entry *p = *slot; > if (!ggc_marked_p (p->ptr)) > { > p->loc->collected += p->size; > @@ -1047,15 +1047,15 @@ ggc_prune_overhead_list (void) > void > ggc_free_overhead (void *ptr) > { > - ptr_hash_entry **slot > + ggc_ptr_hash_entry **slot > = ptr_hash->find_slot_with_hash (ptr, htab_hash_pointer (ptr), > NO_INSERT); > - struct ptr_hash_entry *p; > + struct ggc_ptr_hash_entry *p; > /* The pointer might be not found if a PCH read happened between allocation > and ggc_free () call. FIXME: account memory properly in the presence of > PCH. */ > if (!slot) > return; > - p = (struct ptr_hash_entry *) *slot; > + p = (struct ggc_ptr_hash_entry *) *slot; > p->loc->freed += p->size; > ptr_hash->clear_slot (slot); > free (p); > @@ -1065,10 +1065,10 @@ ggc_free_overhead (void *ptr) > static int > final_cmp_statistic (const void *loc1, const void *loc2) > { > - const struct loc_descriptor *const l1 = > - *(const struct loc_descriptor *const *) loc1; > - const struct loc_descriptor *const l2 = > - *(const struct loc_descriptor *const *) loc2; > + const struct ggc_loc_descriptor *const l1 = > + *(const struct ggc_loc_descriptor *const *) loc1; > + const struct ggc_loc_descriptor *const l2 = > + *(const struct ggc_loc_descriptor *const *) loc2; > long diff; > diff = ((long)(l1->allocated + l1->overhead - l1->freed) - > (l2->allocated + l2->overhead - l2->freed)); > @@ -1079,10 +1079,10 @@ final_cmp_statistic (const void *loc1, c > static int > cmp_statistic (const void *loc1, const void *loc2) > { > - const struct loc_descriptor *const l1 = > - *(const struct loc_descriptor *const *) loc1; > - const struct loc_descriptor *const l2 = > - *(const struct loc_descriptor *const *) loc2; > + const struct ggc_loc_descriptor *const l1 = > + *(const struct ggc_loc_descriptor *const *) loc1; > + const struct ggc_loc_descriptor *const l2 = > + *(const struct ggc_loc_descriptor *const *) loc2; > long diff; > > diff = ((long)(l1->allocated + l1->overhead - l1->freed - l1->collected) - > @@ -1095,9 +1095,9 @@ cmp_statistic (const void *loc1, const v > } > > /* Collect array of the descriptors from hashtable. */ > -static struct loc_descriptor **loc_array; > +static struct ggc_loc_descriptor **loc_array; > int > -ggc_add_statistics (loc_descriptor **slot, int *n) > +ggc_add_statistics (ggc_loc_descriptor **slot, int *n) > { > loc_array[*n] = *slot; > (*n)++; > @@ -1120,7 +1120,7 @@ dump_ggc_loc_statistics (bool final) > ggc_force_collect = true; > ggc_collect (); > > - loc_array = XCNEWVEC (struct loc_descriptor *, > + loc_array = XCNEWVEC (struct ggc_loc_descriptor *, > loc_hash->elements_with_deleted ()); > fprintf (stderr, > "-------------------------------------------------------\n"); > fprintf (stderr, "\n%-48s %10s %10s %10s %10s > %10s\n", > @@ -1131,7 +1131,7 @@ dump_ggc_loc_statistics (bool final) > final ? final_cmp_statistic : cmp_statistic); > for (i = 0; i < nentries; i++) > { > - struct loc_descriptor *d = loc_array[i]; > + struct ggc_loc_descriptor *d = loc_array[i]; > allocated += d->allocated; > times += d->times; > freed += d->freed; > @@ -1140,7 +1140,7 @@ dump_ggc_loc_statistics (bool final) > } > for (i = 0; i < nentries; i++) > { > - struct loc_descriptor *d = loc_array[i]; > + struct ggc_loc_descriptor *d = loc_array[i]; > if (d->allocated) > { > const char *s1 = d->file; > Index: lra-eliminations.c > =================================================================== > --- lra-eliminations.c (revision 215328) > +++ lra-eliminations.c (working copy) > @@ -77,7 +77,7 @@ along with GCC; see the file COPYING3. I > > /* This structure is used to record information about hard register > eliminations. */ > -struct elim_table > +struct lra_elim_table > { > /* Hard register number to be eliminated. */ > int from; > @@ -105,7 +105,7 @@ struct elim_table > of eliminating a register in favor of another. If there is more > than one way of eliminating a particular register, the most > preferred should be specified first. */ > -static struct elim_table *reg_eliminate = 0; > +static struct lra_elim_table *reg_eliminate = 0; > > /* This is an intermediate structure to initialize the table. It has > exactly the members provided by ELIMINABLE_REGS. */ > @@ -131,7 +131,7 @@ static const struct elim_table_1 > static void > print_elim_table (FILE *f) > { > - struct elim_table *ep; > + struct lra_elim_table *ep; > > for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++) > fprintf (f, "%s eliminate %d to %d (offset=" HOST_WIDE_INT_PRINT_DEC > @@ -151,7 +151,7 @@ lra_debug_elim_table (void) > VALUE. Setup FRAME_POINTER_NEEDED if elimination from frame > pointer to stack pointer is not possible anymore. */ > static void > -setup_can_eliminate (struct elim_table *ep, bool value) > +setup_can_eliminate (struct lra_elim_table *ep, bool value) > { > ep->can_eliminate = ep->prev_can_eliminate = value; > if (! value > @@ -163,12 +163,12 @@ setup_can_eliminate (struct elim_table * > or NULL if none. The elimination table may contain more than > one elimination for the same hard register, but this map specifies > the one that we are currently using. */ > -static struct elim_table *elimination_map[FIRST_PSEUDO_REGISTER]; > +static struct lra_elim_table *elimination_map[FIRST_PSEUDO_REGISTER]; > > /* When an eliminable hard register becomes not eliminable, we use the > following special structure to restore original offsets for the > register. */ > -static struct elim_table self_elim_table; > +static struct lra_elim_table self_elim_table; > > /* Offsets should be used to restore original offsets for eliminable > hard register which just became not eliminable. Zero, > @@ -184,7 +184,7 @@ static void > setup_elimination_map (void) > { > int i; > - struct elim_table *ep; > + struct lra_elim_table *ep; > > for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) > elimination_map[i] = NULL; > @@ -249,7 +249,7 @@ form_sum (rtx x, rtx y) > int > lra_get_elimination_hard_regno (int hard_regno) > { > - struct elim_table *ep; > + struct lra_elim_table *ep; > > if (hard_regno < 0 || hard_regno >= FIRST_PSEUDO_REGISTER) > return hard_regno; > @@ -260,11 +260,11 @@ lra_get_elimination_hard_regno (int hard > > /* Return elimination which will be used for hard reg REG, NULL > otherwise. */ > -static struct elim_table * > +static struct lra_elim_table * > get_elimination (rtx reg) > { > int hard_regno; > - struct elim_table *ep; > + struct lra_elim_table *ep; > HOST_WIDE_INT offset; > > lra_assert (REG_P (reg)); > @@ -306,7 +306,7 @@ lra_eliminate_regs_1 (rtx_insn *insn, rt > bool subst_p, bool update_p, bool full_p) > { > enum rtx_code code = GET_CODE (x); > - struct elim_table *ep; > + struct lra_elim_table *ep; > rtx new_rtx; > int i, j; > const char *fmt; > @@ -674,7 +674,7 @@ static void > mark_not_eliminable (rtx x, enum machine_mode mem_mode) > { > enum rtx_code code = GET_CODE (x); > - struct elim_table *ep; > + struct lra_elim_table *ep; > int i, j; > const char *fmt; > > @@ -856,7 +856,7 @@ eliminate_regs_in_insn (rtx_insn *insn, > int i; > rtx substed_operand[MAX_RECOG_OPERANDS]; > rtx orig_operand[MAX_RECOG_OPERANDS]; > - struct elim_table *ep; > + struct lra_elim_table *ep; > rtx plus_src, plus_cst_src; > lra_insn_recog_data_t id; > struct lra_static_insn_data *static_id; > @@ -1130,7 +1130,7 @@ static bool > update_reg_eliminate (bitmap insns_with_changed_offsets) > { > bool prev, result; > - struct elim_table *ep, *ep1; > + struct lra_elim_table *ep, *ep1; > HARD_REG_SET temp_hard_reg_set; > > /* Clear self elimination offsets. */ > @@ -1235,14 +1235,14 @@ update_reg_eliminate (bitmap insns_with_ > static void > init_elim_table (void) > { > - struct elim_table *ep; > + struct lra_elim_table *ep; > #ifdef ELIMINABLE_REGS > bool value_p; > const struct elim_table_1 *ep1; > #endif > > if (!reg_eliminate) > - reg_eliminate = XCNEWVEC (struct elim_table, NUM_ELIMINABLE_REGS); > + reg_eliminate = XCNEWVEC (struct lra_elim_table, NUM_ELIMINABLE_REGS); > > memset (self_elim_offsets, 0, sizeof (self_elim_offsets)); > /* Initiate member values which will be never changed. */ > @@ -1291,7 +1291,7 @@ init_elimination (void) > bool stop_to_sp_elimination_p; > basic_block bb; > rtx_insn *insn; > - struct elim_table *ep; > + struct lra_elim_table *ep; > > init_elim_table (); > FOR_EACH_BB_FN (bb, cfun) > @@ -1325,7 +1325,7 @@ void > lra_eliminate_reg_if_possible (rtx *loc) > { > int regno; > - struct elim_table *ep; > + struct lra_elim_table *ep; > > lra_assert (REG_P (*loc)); > if ((regno = REGNO (*loc)) >= FIRST_PSEUDO_REGISTER > @@ -1369,7 +1369,7 @@ lra_eliminate (bool final_p, bool first_ > unsigned int uid; > bitmap_head insns_with_changed_offsets; > bitmap_iterator bi; > - struct elim_table *ep; > + struct lra_elim_table *ep; > > gcc_assert (! final_p || ! first_p); > > Index: bitmap.c > =================================================================== > --- bitmap.c (revision 215328) > +++ bitmap.c (working copy) > @@ -2143,7 +2143,7 @@ bitmap_print (FILE *file, const_bitmap h > > > /* Used to accumulate statistics about bitmap sizes. */ > -struct output_info > +struct bitmap_output_info > { > uint64_t size; > uint64_t count; > @@ -2152,7 +2152,7 @@ struct output_info > /* Called via hash_table::traverse. Output bitmap descriptor pointed out by > SLOT and update statistics. */ > int > -print_statistics (bitmap_descriptor_d **slot, output_info *i) > +print_statistics (bitmap_descriptor_d **slot, bitmap_output_info *i) > { > bitmap_descriptor d = *slot; > char s[4096]; > @@ -2181,7 +2181,7 @@ print_statistics (bitmap_descriptor_d ** > void > dump_bitmap_statistics (void) > { > - struct output_info info; > + struct bitmap_output_info info; > > if (! GATHER_STATISTICS) > return; > @@ -2197,7 +2197,7 @@ dump_bitmap_statistics (void) > fprintf (stderr, > "---------------------------------------------------------------------------------\n"); > info.count = 0; > info.size = 0; > - bitmap_desc_hash->traverse <output_info *, print_statistics> (&info); > + bitmap_desc_hash->traverse <bitmap_output_info *, print_statistics> > (&info); > fprintf (stderr, > "---------------------------------------------------------------------------------\n"); > fprintf (stderr, > "%-41s %9"PRId64" %15"PRId64"\n", > Index: gcse.c > =================================================================== > --- gcse.c (revision 215328) > +++ gcse.c (working copy) > @@ -256,25 +256,25 @@ static struct obstack gcse_obstack; > > /* Hash table of expressions. */ > > -struct expr > +struct gcse_expr > { > /* The expression. */ > rtx expr; > /* Index in the available expression bitmaps. */ > int bitmap_index; > /* Next entry with the same hash. */ > - struct expr *next_same_hash; > + struct gcse_expr *next_same_hash; > /* List of anticipatable occurrences in basic blocks in the function. > An "anticipatable occurrence" is one that is the first occurrence in the > basic block, the operands are not modified in the basic block prior > to the occurrence and the output is not used between the start of > the block and the occurrence. */ > - struct occr *antic_occr; > + struct gcse_occr *antic_occr; > /* List of available occurrence in basic blocks in the function. > An "available occurrence" is one that is the last occurrence in the > basic block and the operands are not modified by following statements in > the basic block [including this insn]. */ > - struct occr *avail_occr; > + struct gcse_occr *avail_occr; > /* Non-null if the computation is PRE redundant. > The value is the newly created pseudo-reg to record a copy of the > expression in all the places that reach the redundant copy. */ > @@ -291,10 +291,10 @@ struct expr > There is one per basic block. If a pattern appears more than once the > last appearance is used [or first for anticipatable expressions]. */ > > -struct occr > +struct gcse_occr > { > /* Next occurrence of this expression. */ > - struct occr *next; > + struct gcse_occr *next; > /* The insn that computes the expression. */ > rtx_insn *insn; > /* Nonzero if this [anticipatable] occurrence has been deleted. */ > @@ -306,7 +306,7 @@ struct occr > char copied_p; > }; > > -typedef struct occr *occr_t; > +typedef struct gcse_occr *occr_t; > > /* Expression hash tables. > Each hash table is an array of buckets. > @@ -317,11 +317,11 @@ typedef struct occr *occr_t; > [one could build a mapping table without holes afterwards though]. > Someday I'll perform the computation and figure it out. */ > > -struct hash_table_d > +struct gcse_hash_table_d > { > /* The table itself. > This is an array of `expr_hash_table_size' elements. */ > - struct expr **table; > + struct gcse_expr **table; > > /* Size of the hash table, in elements. */ > unsigned int size; > @@ -331,7 +331,7 @@ struct hash_table_d > }; > > /* Expression hash table. */ > -static struct hash_table_d expr_hash_table; > +static struct gcse_hash_table_d expr_hash_table; > > /* This is a list of expressions which are MEMs and will be used by load > or store motion. > @@ -344,7 +344,7 @@ static struct hash_table_d expr_hash_tab > > struct ls_expr > { > - struct expr * expr; /* Gcse expression reference for LM. */ > + struct gcse_expr * expr; /* Gcse expression reference for LM. */ > rtx pattern; /* Pattern of this mem. */ > rtx pattern_regs; /* List of registers mentioned by the mem. */ > rtx_insn_list *loads; /* INSN list of loads seen. */ > @@ -462,38 +462,38 @@ static void *gcalloc (size_t, size_t) AT > static void *gcse_alloc (unsigned long); > static void alloc_gcse_mem (void); > static void free_gcse_mem (void); > -static void hash_scan_insn (rtx_insn *, struct hash_table_d *); > -static void hash_scan_set (rtx, rtx_insn *, struct hash_table_d *); > -static void hash_scan_clobber (rtx, rtx_insn *, struct hash_table_d *); > -static void hash_scan_call (rtx, rtx_insn *, struct hash_table_d *); > +static void hash_scan_insn (rtx_insn *, struct gcse_hash_table_d *); > +static void hash_scan_set (rtx, rtx_insn *, struct gcse_hash_table_d *); > +static void hash_scan_clobber (rtx, rtx_insn *, struct gcse_hash_table_d *); > +static void hash_scan_call (rtx, rtx_insn *, struct gcse_hash_table_d *); > static int want_to_gcse_p (rtx, int *); > static int oprs_unchanged_p (const_rtx, const rtx_insn *, int); > static int oprs_anticipatable_p (const_rtx, const rtx_insn *); > static int oprs_available_p (const_rtx, const rtx_insn *); > static void insert_expr_in_table (rtx, enum machine_mode, rtx_insn *, int, > int, > - int, struct hash_table_d *); > + int, struct gcse_hash_table_d *); > static unsigned int hash_expr (const_rtx, enum machine_mode, int *, int); > static void record_last_reg_set_info (rtx, int); > static void record_last_mem_set_info (rtx_insn *); > static void record_last_set_info (rtx, const_rtx, void *); > -static void compute_hash_table (struct hash_table_d *); > -static void alloc_hash_table (struct hash_table_d *); > -static void free_hash_table (struct hash_table_d *); > -static void compute_hash_table_work (struct hash_table_d *); > -static void dump_hash_table (FILE *, const char *, struct hash_table_d *); > +static void compute_hash_table (struct gcse_hash_table_d *); > +static void alloc_hash_table (struct gcse_hash_table_d *); > +static void free_hash_table (struct gcse_hash_table_d *); > +static void compute_hash_table_work (struct gcse_hash_table_d *); > +static void dump_hash_table (FILE *, const char *, struct gcse_hash_table_d > *); > static void compute_transp (const_rtx, int, sbitmap *); > static void compute_local_properties (sbitmap *, sbitmap *, sbitmap *, > - struct hash_table_d *); > + struct gcse_hash_table_d *); > static void mems_conflict_for_gcse_p (rtx, const_rtx, void *); > static int load_killed_in_block_p (const_basic_block, int, const_rtx, int); > static void canon_list_insert (rtx, const_rtx, void *); > static void alloc_pre_mem (int, int); > static void free_pre_mem (void); > static struct edge_list *compute_pre_data (void); > -static int pre_expr_reaches_here_p (basic_block, struct expr *, > +static int pre_expr_reaches_here_p (basic_block, struct gcse_expr *, > basic_block); > -static void insert_insn_end_basic_block (struct expr *, basic_block); > -static void pre_insert_copy_insn (struct expr *, rtx_insn *); > +static void insert_insn_end_basic_block (struct gcse_expr *, basic_block); > +static void pre_insert_copy_insn (struct gcse_expr *, rtx_insn *); > static void pre_insert_copies (void); > static int pre_delete (void); > static int pre_gcse (struct edge_list *); > @@ -503,16 +503,16 @@ static void alloc_code_hoist_mem (int, i > static void free_code_hoist_mem (void); > static void compute_code_hoist_vbeinout (void); > static void compute_code_hoist_data (void); > -static int should_hoist_expr_to_dom (basic_block, struct expr *, basic_block, > +static int should_hoist_expr_to_dom (basic_block, struct gcse_expr *, > basic_block, > sbitmap, int, int *, enum reg_class, > int *, bitmap, rtx_insn *); > static int hoist_code (void); > static enum reg_class get_regno_pressure_class (int regno, int *nregs); > static enum reg_class get_pressure_class_and_nregs (rtx_insn *insn, int > *nregs); > static int one_code_hoisting_pass (void); > -static rtx_insn *process_insert_insn (struct expr *); > -static int pre_edge_insert (struct edge_list *, struct expr **); > -static int pre_expr_reaches_here_p_work (basic_block, struct expr *, > +static rtx_insn *process_insert_insn (struct gcse_expr *); > +static int pre_edge_insert (struct edge_list *, struct gcse_expr **); > +static int pre_expr_reaches_here_p_work (basic_block, struct gcse_expr *, > basic_block, char *); > static struct ls_expr * ldst_entry (rtx); > static void free_ldst_entry (struct ls_expr *); > @@ -523,7 +523,7 @@ static int simple_mem (const_rtx); > static void invalidate_any_buried_refs (rtx); > static void compute_ld_motion_mems (void); > static void trim_ld_motion_mems (void); > -static void update_ld_motion_stores (struct expr *); > +static void update_ld_motion_stores (struct gcse_expr *); > static void clear_modify_mem_tables (void); > static void free_modify_mem_tables (void); > static rtx gcse_emit_move_after (rtx, rtx, rtx_insn *); > @@ -679,7 +679,7 @@ free_gcse_mem (void) > > static void > compute_local_properties (sbitmap *transp, sbitmap *comp, sbitmap *antloc, > - struct hash_table_d *table) > + struct gcse_hash_table_d *table) > { > unsigned int i; > > @@ -696,12 +696,12 @@ compute_local_properties (sbitmap *trans > > for (i = 0; i < table->size; i++) > { > - struct expr *expr; > + struct gcse_expr *expr; > > for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash) > { > int indx = expr->bitmap_index; > - struct occr *occr; > + struct gcse_occr *occr; > > /* The expression is transparent in this block if it is not killed. > We start by assuming all are transparent [none are killed], and > @@ -1128,12 +1128,12 @@ expr_equiv_p (const_rtx x, const_rtx y) > static void > insert_expr_in_table (rtx x, enum machine_mode mode, rtx_insn *insn, > int antic_p, > - int avail_p, int max_distance, struct hash_table_d *table) > + int avail_p, int max_distance, struct gcse_hash_table_d > *table) > { > int found, do_not_record_p; > unsigned int hash; > - struct expr *cur_expr, *last_expr = NULL; > - struct occr *antic_occr, *avail_occr; > + struct gcse_expr *cur_expr, *last_expr = NULL; > + struct gcse_occr *antic_occr, *avail_occr; > > hash = hash_expr (x, mode, &do_not_record_p, table->size); > > @@ -1156,8 +1156,8 @@ insert_expr_in_table (rtx x, enum machin > > if (! found) > { > - cur_expr = GOBNEW (struct expr); > - bytes_used += sizeof (struct expr); > + cur_expr = GOBNEW (struct gcse_expr); > + bytes_used += sizeof (struct gcse_expr); > if (table->table[hash] == NULL) > /* This is the first pattern that hashed to this index. */ > table->table[hash] = cur_expr; > @@ -1194,8 +1194,8 @@ insert_expr_in_table (rtx x, enum machin > else > { > /* First occurrence of this expression in this basic block. */ > - antic_occr = GOBNEW (struct occr); > - bytes_used += sizeof (struct occr); > + antic_occr = GOBNEW (struct gcse_occr); > + bytes_used += sizeof (struct gcse_occr); > antic_occr->insn = insn; > antic_occr->next = cur_expr->antic_occr; > antic_occr->deleted_p = 0; > @@ -1219,8 +1219,8 @@ insert_expr_in_table (rtx x, enum machin > else > { > /* First occurrence of this expression in this basic block. */ > - avail_occr = GOBNEW (struct occr); > - bytes_used += sizeof (struct occr); > + avail_occr = GOBNEW (struct gcse_occr); > + bytes_used += sizeof (struct gcse_occr); > avail_occr->insn = insn; > avail_occr->next = cur_expr->avail_occr; > avail_occr->deleted_p = 0; > @@ -1232,7 +1232,7 @@ insert_expr_in_table (rtx x, enum machin > /* Scan SET present in INSN and add an entry to the hash TABLE. */ > > static void > -hash_scan_set (rtx set, rtx_insn *insn, struct hash_table_d *table) > +hash_scan_set (rtx set, rtx_insn *insn, struct gcse_hash_table_d *table) > { > rtx src = SET_SRC (set); > rtx dest = SET_DEST (set); > @@ -1352,14 +1352,14 @@ hash_scan_set (rtx set, rtx_insn *insn, > > static void > hash_scan_clobber (rtx x ATTRIBUTE_UNUSED, rtx_insn *insn ATTRIBUTE_UNUSED, > - struct hash_table_d *table ATTRIBUTE_UNUSED) > + struct gcse_hash_table_d *table ATTRIBUTE_UNUSED) > { > /* Currently nothing to do. */ > } > > static void > hash_scan_call (rtx x ATTRIBUTE_UNUSED, rtx_insn *insn ATTRIBUTE_UNUSED, > - struct hash_table_d *table ATTRIBUTE_UNUSED) > + struct gcse_hash_table_d *table ATTRIBUTE_UNUSED) > { > /* Currently nothing to do. */ > } > @@ -1367,7 +1367,7 @@ hash_scan_call (rtx x ATTRIBUTE_UNUSED, > /* Process INSN and add hash table entries as appropriate. */ > > static void > -hash_scan_insn (rtx_insn *insn, struct hash_table_d *table) > +hash_scan_insn (rtx_insn *insn, struct gcse_hash_table_d *table) > { > rtx pat = PATTERN (insn); > int i; > @@ -1401,15 +1401,15 @@ hash_scan_insn (rtx_insn *insn, struct h > /* Dump the hash table TABLE to file FILE under the name NAME. */ > > static void > -dump_hash_table (FILE *file, const char *name, struct hash_table_d *table) > +dump_hash_table (FILE *file, const char *name, struct gcse_hash_table_d > *table) > { > int i; > /* Flattened out table, so it's printed in proper order. */ > - struct expr **flat_table; > + struct gcse_expr **flat_table; > unsigned int *hash_val; > - struct expr *expr; > + struct gcse_expr *expr; > > - flat_table = XCNEWVEC (struct expr *, table->n_elems); > + flat_table = XCNEWVEC (struct gcse_expr *, table->n_elems); > hash_val = XNEWVEC (unsigned int, table->n_elems); > > for (i = 0; i < (int) table->size; i++) > @@ -1553,7 +1553,7 @@ record_last_set_info (rtx dest, const_rt > TABLE is the table computed. */ > > static void > -compute_hash_table_work (struct hash_table_d *table) > +compute_hash_table_work (struct gcse_hash_table_d *table) > { > int i; > > @@ -1605,7 +1605,7 @@ compute_hash_table_work (struct hash_tab > It is used to determine the number of buckets to use. */ > > static void > -alloc_hash_table (struct hash_table_d *table) > +alloc_hash_table (struct gcse_hash_table_d *table) > { > int n; > > @@ -1619,14 +1619,14 @@ alloc_hash_table (struct hash_table_d *t > Making it an odd number is simplest for now. > ??? Later take some measurements. */ > table->size |= 1; > - n = table->size * sizeof (struct expr *); > - table->table = GNEWVAR (struct expr *, n); > + n = table->size * sizeof (struct gcse_expr *); > + table->table = GNEWVAR (struct gcse_expr *, n); > } > > /* Free things allocated by alloc_hash_table. */ > > static void > -free_hash_table (struct hash_table_d *table) > +free_hash_table (struct gcse_hash_table_d *table) > { > free (table->table); > } > @@ -1634,11 +1634,11 @@ free_hash_table (struct hash_table_d *ta > /* Compute the expression hash table TABLE. */ > > static void > -compute_hash_table (struct hash_table_d *table) > +compute_hash_table (struct gcse_hash_table_d *table) > { > /* Initialize count of number of entries in hash table. */ > table->n_elems = 0; > - memset (table->table, 0, table->size * sizeof (struct expr *)); > + memset (table->table, 0, table->size * sizeof (struct gcse_expr *)); > > compute_hash_table_work (table); > } > @@ -1864,7 +1864,7 @@ static void > prune_expressions (bool pre_p) > { > sbitmap prune_exprs; > - struct expr *expr; > + struct gcse_expr *expr; > unsigned int ui; > basic_block bb; > > @@ -2063,7 +2063,7 @@ compute_pre_data (void) > the closest such expression. */ > > static int > -pre_expr_reaches_here_p_work (basic_block occr_bb, struct expr *expr, > +pre_expr_reaches_here_p_work (basic_block occr_bb, struct gcse_expr *expr, > basic_block bb, char *visited) > { > edge pred; > @@ -2110,7 +2110,7 @@ pre_expr_reaches_here_p_work (basic_bloc > memory allocated for that function is returned. */ > > static int > -pre_expr_reaches_here_p (basic_block occr_bb, struct expr *expr, basic_block > bb) > +pre_expr_reaches_here_p (basic_block occr_bb, struct gcse_expr *expr, > basic_block bb) > { > int rval; > char *visited = XCNEWVEC (char, last_basic_block_for_fn (cfun)); > @@ -2124,7 +2124,7 @@ pre_expr_reaches_here_p (basic_block occ > /* Generate RTL to copy an EXPR to its `reaching_reg' and return it. */ > > static rtx_insn * > -process_insert_insn (struct expr *expr) > +process_insert_insn (struct gcse_expr *expr) > { > rtx reg = expr->reaching_reg; > /* Copy the expression to make sure we don't have any sharing issues. */ > @@ -2159,7 +2159,7 @@ process_insert_insn (struct expr *expr) > This is used by both the PRE and code hoisting. */ > > static void > -insert_insn_end_basic_block (struct expr *expr, basic_block bb) > +insert_insn_end_basic_block (struct gcse_expr *expr, basic_block bb) > { > rtx_insn *insn = BB_END (bb); > rtx_insn *new_insn; > @@ -2259,7 +2259,7 @@ insert_insn_end_basic_block (struct expr > the expressions fully redundant. */ > > static int > -pre_edge_insert (struct edge_list *edge_list, struct expr **index_map) > +pre_edge_insert (struct edge_list *edge_list, struct gcse_expr **index_map) > { > int e, i, j, num_edges, set_size, did_insert = 0; > sbitmap *inserted; > @@ -2286,8 +2286,8 @@ pre_edge_insert (struct edge_list *edge_ > j++, insert >>= 1) > if ((insert & 1) != 0 && index_map[j]->reaching_reg != NULL_RTX) > { > - struct expr *expr = index_map[j]; > - struct occr *occr; > + struct gcse_expr *expr = index_map[j]; > + struct gcse_occr *occr; > > /* Now look at each deleted occurrence of this expression. */ > for (occr = expr->antic_occr; occr != NULL; occr = occr->next) > @@ -2356,7 +2356,7 @@ pre_edge_insert (struct edge_list *edge_ > MEM <- reaching_reg. */ > > static void > -pre_insert_copy_insn (struct expr *expr, rtx_insn *insn) > +pre_insert_copy_insn (struct gcse_expr *expr, rtx_insn *insn) > { > rtx reg = expr->reaching_reg; > int regno = REGNO (reg); > @@ -2448,9 +2448,9 @@ static void > pre_insert_copies (void) > { > unsigned int i, added_copy; > - struct expr *expr; > - struct occr *occr; > - struct occr *avail; > + struct gcse_expr *expr; > + struct gcse_occr *occr; > + struct gcse_occr *avail; > > /* For each available expression in the table, copy the result to > `reaching_reg' if the expression reaches a deleted one. > @@ -2614,8 +2614,8 @@ pre_delete (void) > { > unsigned int i; > int changed; > - struct expr *expr; > - struct occr *occr; > + struct gcse_expr *expr; > + struct gcse_occr *occr; > > changed = 0; > for (i = 0; i < expr_hash_table.size; i++) > @@ -2687,13 +2687,13 @@ pre_gcse (struct edge_list *edge_list) > { > unsigned int i; > int did_insert, changed; > - struct expr **index_map; > - struct expr *expr; > + struct gcse_expr **index_map; > + struct gcse_expr *expr; > > /* Compute a mapping from expression number (`bitmap_index') to > hash table entry. */ > > - index_map = XCNEWVEC (struct expr *, expr_hash_table.n_elems); > + index_map = XCNEWVEC (struct gcse_expr *, expr_hash_table.n_elems); > for (i = 0; i < expr_hash_table.size; i++) > for (expr = expr_hash_table.table[i]; expr; expr = expr->next_same_hash) > index_map[expr->bitmap_index] = expr; > @@ -3042,7 +3042,7 @@ update_bb_reg_pressure (basic_block bb, > paths. */ > > static int > -should_hoist_expr_to_dom (basic_block expr_bb, struct expr *expr, > +should_hoist_expr_to_dom (basic_block expr_bb, struct gcse_expr *expr, > basic_block bb, sbitmap visited, int distance, > int *bb_size, enum reg_class pressure_class, > int *nregs, bitmap hoisted_bbs, rtx_insn *from) > @@ -3150,8 +3150,8 @@ should_hoist_expr_to_dom (basic_block ex > > /* Find occurrence in BB. */ > > -static struct occr * > -find_occr_in_bb (struct occr *occr, basic_block bb) > +static struct gcse_occr * > +find_occr_in_bb (struct gcse_occr *occr, basic_block bb) > { > /* Find the right occurrence of this expression. */ > while (occr && BLOCK_FOR_INSN (occr->insn) != bb) > @@ -3212,8 +3212,8 @@ hoist_code (void) > unsigned int dom_tree_walk_index; > vec<basic_block> domby; > unsigned int i, j, k; > - struct expr **index_map; > - struct expr *expr; > + struct gcse_expr **index_map; > + struct gcse_expr *expr; > int *to_bb_head; > int *bb_size; > int changed = 0; > @@ -3227,7 +3227,7 @@ hoist_code (void) > /* Compute a mapping from expression number (`bitmap_index') to > hash table entry. */ > > - index_map = XCNEWVEC (struct expr *, expr_hash_table.n_elems); > + index_map = XCNEWVEC (struct gcse_expr *, expr_hash_table.n_elems); > for (i = 0; i < expr_hash_table.size; i++) > for (expr = expr_hash_table.table[i]; expr; expr = expr->next_same_hash) > index_map[expr->bitmap_index] = expr; > @@ -3285,7 +3285,7 @@ hoist_code (void) > int nregs = 0; > enum reg_class pressure_class = NO_REGS; > /* Current expression. */ > - struct expr *expr = index_map[i]; > + struct gcse_expr *expr = index_map[i]; > /* Number of occurrences of EXPR that can be hoisted to BB. */ > int hoistable = 0; > /* Occurrences reachable from BB. */ > @@ -4028,7 +4028,7 @@ trim_ld_motion_mems (void) > > while (ptr != NULL) > { > - struct expr * expr; > + struct gcse_expr * expr; > > /* Delete if entry has been made invalid. */ > if (! ptr->invalid) > @@ -4043,7 +4043,7 @@ trim_ld_motion_mems (void) > break; > } > else > - expr = (struct expr *) 0; > + expr = (struct gcse_expr *) 0; > > if (expr) > { > @@ -4074,7 +4074,7 @@ trim_ld_motion_mems (void) > correct value in the reaching register for the loads. */ > > static void > -update_ld_motion_stores (struct expr * expr) > +update_ld_motion_stores (struct gcse_expr * expr) > { > struct ls_expr * mem_ptr; > > Index: tree-ssa-copy.c > =================================================================== > --- tree-ssa-copy.c (revision 215328) > +++ tree-ssa-copy.c (working copy) > @@ -76,11 +76,10 @@ along with GCC; see the file COPYING3. > When visiting a statement or PHI node the lattice value for an > SSA name can transition from UNDEFINED to COPY to VARYING. */ > > -struct prop_value_d { > +struct prop_value_t { > /* Copy-of value. */ > tree value; > }; > -typedef struct prop_value_d prop_value_t; > > static prop_value_t *copy_of; > static unsigned n_copy_of; > Index: predict.c > =================================================================== > --- predict.c (revision 215328) > +++ predict.c (working copy) > @@ -2496,7 +2496,7 @@ predict_paths_leading_to_edge (edge e, e > /* This is used to carry information about basic blocks. It is > attached to the AUX field of the standard CFG block. */ > > -typedef struct block_info_def > +struct block_info > { > /* Estimated frequency of execution of basic_block. */ > sreal frequency; > @@ -2506,10 +2506,10 @@ typedef struct block_info_def > > /* Number of predecessors we need to visit first. */ > int npredecessors; > -} *block_info; > +}; > > /* Similar information for edges. */ > -typedef struct edge_info_def > +struct edge_info > { > /* In case edge is a loopback edge, the probability edge will be reached > in case header is. Estimated number of iterations of the loop can be > @@ -2517,10 +2517,10 @@ typedef struct edge_info_def > sreal back_edge_prob; > /* True if the edge is a loopback edge in the natural loop. */ > unsigned int back_edge:1; > -} *edge_info; > +}; > > -#define BLOCK_INFO(B) ((block_info) (B)->aux) > -#define EDGE_INFO(E) ((edge_info) (E)->aux) > +#define BLOCK_INFO(B) ((block_info *) (B)->aux) > +#define EDGE_INFO(E) ((edge_info *) (E)->aux) > > /* Helper function for estimate_bb_frequencies. > Propagate the frequencies in blocks marked in > @@ -2935,8 +2935,8 @@ estimate_bb_frequencies (bool force) > REG_BR_PROB_BASE; > > /* Set up block info for each basic block. */ > - alloc_aux_for_blocks (sizeof (struct block_info_def)); > - alloc_aux_for_edges (sizeof (struct edge_info_def)); > + alloc_aux_for_blocks (sizeof (block_info)); > + alloc_aux_for_edges (sizeof (edge_info)); > FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb) > { > edge e; > Index: profile.c > =================================================================== > --- profile.c (revision 215328) > +++ profile.c (working copy) > @@ -74,7 +74,7 @@ along with GCC; see the file COPYING3. > > #include "profile.h" > > -struct bb_info { > +struct bb_profile_info { > unsigned int count_valid : 1; > > /* Number of successor and predecessor edges. */ > @@ -82,7 +82,7 @@ struct bb_info { > gcov_type pred_count; > }; > > -#define BB_INFO(b) ((struct bb_info *) (b)->aux) > +#define BB_INFO(b) ((struct bb_profile_info *) (b)->aux) > > > /* Counter summary from the last set of coverage counts read. */ > @@ -128,7 +128,7 @@ instrument_edges (struct edge_list *el) > > FOR_EACH_EDGE (e, ei, bb->succs) > { > - struct edge_info *inf = EDGE_INFO (e); > + struct edge_profile_info *inf = EDGE_INFO (e); > > if (!inf->ignore && !inf->on_tree) > { > @@ -542,7 +542,7 @@ compute_branch_probabilities (unsigned c > } > > /* Attach extra info block to each bb. */ > - alloc_aux_for_blocks (sizeof (struct bb_info)); > + alloc_aux_for_blocks (sizeof (struct bb_profile_info)); > FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb) > { > edge e; > @@ -590,7 +590,7 @@ compute_branch_probabilities (unsigned c > changes = 0; > FOR_BB_BETWEEN (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, prev_bb) > { > - struct bb_info *bi = BB_INFO (bb); > + struct bb_profile_info *bi = BB_INFO (bb); > if (! bi->count_valid) > { > if (bi->succ_count == 0) > @@ -1129,7 +1129,7 @@ branch_prob (void) > > el = create_edge_list (); > num_edges = NUM_EDGES (el); > - alloc_aux_for_edges (sizeof (struct edge_info)); > + alloc_aux_for_edges (sizeof (struct edge_profile_info)); > > /* The basic blocks are expected to be numbered sequentially. */ > compact_blocks (); > @@ -1161,7 +1161,7 @@ branch_prob (void) > for (num_instrumented = i = 0; i < num_edges; i++) > { > edge e = INDEX_EDGE (el, i); > - struct edge_info *inf = EDGE_INFO (e); > + struct edge_profile_info *inf = EDGE_INFO (e); > > if (inf->ignore || inf->on_tree) > /*NOP*/; > @@ -1221,7 +1221,7 @@ branch_prob (void) > > FOR_EACH_EDGE (e, ei, bb->succs) > { > - struct edge_info *i = EDGE_INFO (e); > + struct edge_profile_info *i = EDGE_INFO (e); > if (!i->ignore) > { > unsigned flag_bits = 0; > Index: profile.h > =================================================================== > --- profile.h (revision 215328) > +++ profile.h (working copy) > @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. > #define PROFILE_H > > /* Additional information about edges. */ > -struct edge_info > +struct edge_profile_info > { > unsigned int count_valid:1; > > @@ -35,7 +35,7 @@ struct edge_info > unsigned int ignore:1; > }; > > -#define EDGE_INFO(e) ((struct edge_info *) (e)->aux) > +#define EDGE_INFO(e) ((struct edge_profile_info *) (e)->aux) > > /* Smoothes the initial assigned basic block and edge counts using > a minimum cost flow algorithm. */ > Index: alloc-pool.c > =================================================================== > --- alloc-pool.c (revision 215328) > +++ alloc-pool.c (working copy) > @@ -339,7 +339,7 @@ pool_free (alloc_pool pool, void *ptr) > /* Output per-alloc_pool statistics. */ > > /* Used to accumulate statistics about alloc_pool sizes. */ > -struct output_info > +struct pool_output_info > { > unsigned long total_created; > unsigned long total_allocated; > @@ -350,7 +350,7 @@ struct output_info > bool > print_alloc_pool_statistics (const char *const &name, > const alloc_pool_descriptor &d, > - struct output_info *i) > + struct pool_output_info *i) > { > if (d.allocated) > { > @@ -369,7 +369,7 @@ print_alloc_pool_statistics (const char > void > dump_alloc_pool_statistics (void) > { > - struct output_info info; > + struct pool_output_info info; > > if (! GATHER_STATISTICS) > return; > @@ -381,7 +381,7 @@ dump_alloc_pool_statistics (void) > fprintf (stderr, > "--------------------------------------------------------------------------------------------------------------\n"); > info.total_created = 0; > info.total_allocated = 0; > - alloc_pool_hash->traverse <struct output_info *, > + alloc_pool_hash->traverse <struct pool_output_info *, > print_alloc_pool_statistics> (&info); > fprintf (stderr, > "--------------------------------------------------------------------------------------------------------------\n"); > fprintf (stderr, "%-22s %7lu %10lu\n", > > -- Richard Biener <rguent...@suse.de> SUSE / SUSE Labs SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 GF: Jeff Hawn, Jennifer Guild, Felix Imend"orffer