tree-ssa-ccp.c (prop_value_d): Rename to ...

	* 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_info): ... this; update uses.
	* 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.
	* ipa-cp.c (topo_info): Rename to ..
	(ipa_topo_info): ... this; update uses.
	* tree-nrv.c (nrv_data): Rename to ...
	(nrv_data_t): ... this; update uses.
	* ipa-split.c (bb_info): Rename to ...
	(split_bb_info): ... this one.
	* profile.h (edge_info): Rename to ...
	(edge_profile_info): ... this one; update uses.
	* dse.c (bb_info): Rename to ...
	(dse_bb_info): ... this one; update uses.
	* cprop.c (occr): Rename to ...
	(cprop_occr): ... this one; update uses.
	(expr): Rename to ...
	(cprop_expr): ... this one; update uses.

From-SVN: r215480

1 files changed, 84 insertions, 84 deletions

diff --git a/gcc/gcse.c b/gcc/gcse.c
index 810d7d6a12e..7c629418e6f 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -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_table;
 
 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) ATTRIBUTE_MALLOC;
 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, int);
 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 *transp, sbitmap *comp, sbitmap *antloc,
 
   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 machine_mode mode, rtx_insn *insn,
 
   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 machine_mode mode, rtx_insn *insn,
       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 machine_mode mode, rtx_insn *insn,
       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 machine_mode mode, rtx_insn *insn,
 /* 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, struct hash_table_d *table)
 
 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, rtx_insn *insn 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 hash_table_d *table)
 /* 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_rtx setter ATTRIBUTE_UNUSED, void *data)
    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_table_d *table)
    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 *table)
      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 *table)
 /* 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_block occr_bb, struct expr *expr,
    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 occr_bb, struct expr *expr, basic_block bb)
 /* 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 *expr, basic_block bb)
    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_list, struct expr **index_map)
 	       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_list, struct expr **index_map)
      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, rtx_insn *from)
    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 expr_bb, struct expr *expr,
 
 /* 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;