Subversion Repositories openrisc

/* RTL dead store elimination.

   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

   Contributed by Richard Sandiford <rsandifor@codesourcery.com>

   and Kenneth Zadeck <zadeck@naturalbridge.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#undef BASELINE

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "hashtab.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "tm_p.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "flags.h"

#include "df.h"

#include "cselib.h"

#include "timevar.h"

#include "tree-pass.h"

#include "alloc-pool.h"

#include "alias.h"

#include "insn-config.h"

#include "expr.h"

#include "recog.h"

#include "dse.h"

#include "optabs.h"

#include "dbgcnt.h"

#include "target.h"

/* This file contains three techniques for performing Dead Store

   Elimination (dse).

   * The first technique performs dse locally on any base address.  It

   is based on the cselib which is a local value numbering technique.

   This technique is local to a basic block but deals with a fairly

   general addresses.

   * The second technique performs dse globally but is restricted to

   base addresses that are either constant or are relative to the

   frame_pointer.

   * The third technique, (which is only done after register allocation)

   processes the spill spill slots.  This differs from the second

   technique because it takes advantage of the fact that spilling is

   completely free from the effects of aliasing.

   Logically, dse is a backwards dataflow problem.  A store can be

   deleted if it if cannot be reached in the backward direction by any

   use of the value being stored.  However, the local technique uses a

   forwards scan of the basic block because cselib requires that the

   block be processed in that order.

   The pass is logically broken into 7 steps:

   0) Initialization.

   1) The local algorithm, as well as scanning the insns for the two

   global algorithms.

   2) Analysis to see if the global algs are necessary.  In the case

   of stores base on a constant address, there must be at least two

   stores to that address, to make it possible to delete some of the

   stores.  In the case of stores off of the frame or spill related

   stores, only one store to an address is necessary because those

   stores die at the end of the function.

   3) Set up the global dataflow equations based on processing the

   info parsed in the first step.

   4) Solve the dataflow equations.

   5) Delete the insns that the global analysis has indicated are

   unnecessary.

   6) Delete insns that store the same value as preceeding store

   where the earlier store couldn't be eliminated.

   7) Cleanup.

   This step uses cselib and canon_rtx to build the largest expression

   possible for each address.  This pass is a forwards pass through

   each basic block.  From the point of view of the global technique,

   the first pass could examine a block in either direction.  The

   forwards ordering is to accommodate cselib.

   We a simplifying assumption: addresses fall into four broad

   categories:

   1) base has rtx_varies_p == false, offset is constant.

   2) base has rtx_varies_p == false, offset variable.

   3) base has rtx_varies_p == true, offset constant.

   4) base has rtx_varies_p == true, offset variable.

   The local passes are able to process all 4 kinds of addresses.  The

   global pass only handles (1).

   The global problem is formulated as follows:

     A store, S1, to address A, where A is not relative to the stack

     frame, can be eliminated if all paths from S1 to the end of the

     of the function contain another store to A before a read to A.

     If the address A is relative to the stack frame, a store S2 to A

     can be eliminated if there are no paths from S1 that reach the

     end of the function that read A before another store to A.  In

     this case S2 can be deleted if there are paths to from S2 to the

     end of the function that have no reads or writes to A.  This

     second case allows stores to the stack frame to be deleted that

     would otherwise die when the function returns.  This cannot be

     done if stores_off_frame_dead_at_return is not true.  See the doc

     for that variable for when this variable is false.

     The global problem is formulated as a backwards set union

     dataflow problem where the stores are the gens and reads are the

     kills.  Set union problems are rare and require some special

     handling given our representation of bitmaps.  A straightforward

     implementation of requires a lot of bitmaps filled with 1s.

     These are expensive and cumbersome in our bitmap formulation so

     care has been taken to avoid large vectors filled with 1s.  See

     the comments in bb_info and in the dataflow confluence functions

     for details.

   There are two places for further enhancements to this algorithm:

   1) The original dse which was embedded in a pass called flow also

   did local address forwarding.  For example in

   A <- r100

   ... <- A

   flow would replace the right hand side of the second insn with a

   reference to r100.  Most of the information is available to add this

   to this pass.  It has not done it because it is a lot of work in

   the case that either r100 is assigned to between the first and

   second insn and/or the second insn is a load of part of the value

   stored by the first insn.

   insn 5 in gcc.c-torture/compile/990203-1.c simple case.

   insn 15 in gcc.c-torture/execute/20001017-2.c simple case.

   insn 25 in gcc.c-torture/execute/20001026-1.c simple case.

   insn 44 in gcc.c-torture/execute/20010910-1.c simple case.

   2) The cleaning up of spill code is quite profitable.  It currently

   depends on reading tea leaves and chicken entrails left by reload.

   This pass depends on reload creating a singleton alias set for each

   spill slot and telling the next dse pass which of these alias sets

   are the singletons.  Rather than analyze the addresses of the

   spills, dse's spill processing just does analysis of the loads and

   stores that use those alias sets.  There are three cases where this

   falls short:

     a) Reload sometimes creates the slot for one mode of access, and

     then inserts loads and/or stores for a smaller mode.  In this

     case, the current code just punts on the slot.  The proper thing

     to do is to back out and use one bit vector position for each

     byte of the entity associated with the slot.  This depends on

     KNOWING that reload always generates the accesses for each of the

     bytes in some canonical (read that easy to understand several

     passes after reload happens) way.

     b) Reload sometimes decides that spill slot it allocated was not

     large enough for the mode and goes back and allocates more slots

     with the same mode and alias set.  The backout in this case is a

     little more graceful than (a).  In this case the slot is unmarked

     as being a spill slot and if final address comes out to be based

     off the frame pointer, the global algorithm handles this slot.

     c) For any pass that may prespill, there is currently no

     mechanism to tell the dse pass that the slot being used has the

     special properties that reload uses.  It may be that all that is

     required is to have those passes make the same calls that reload

     does, assuming that the alias sets can be manipulated in the same

     way.  */

/* There are limits to the size of constant offsets we model for the

   global problem.  There are certainly test cases, that exceed this

   limit, however, it is unlikely that there are important programs

   that really have constant offsets this size.  */

#define MAX_OFFSET (64 * 1024)

static bitmap scratch = NULL;

struct insn_info;

/* This structure holds information about a candidate store.  */

struct store_info

{

  /* False means this is a clobber.  */

  bool is_set;

  /* False if a single HOST_WIDE_INT bitmap is used for positions_needed.  */

  bool is_large;

  /* The id of the mem group of the base address.  If rtx_varies_p is

     true, this is -1.  Otherwise, it is the index into the group

     table.  */

  int group_id;

  /* This is the cselib value.  */

  cselib_val *cse_base;

  /* This canonized mem.  */

  rtx mem;

  /* Canonized MEM address for use by canon_true_dependence.  */

  rtx mem_addr;

  /* If this is non-zero, it is the alias set of a spill location.  */

  alias_set_type alias_set;

  /* The offset of the first and byte before the last byte associated

     with the operation.  */

  HOST_WIDE_INT begin, end;

  union

    {

      /* A bitmask as wide as the number of bytes in the word that

         contains a 1 if the byte may be needed.  The store is unused if

         all of the bits are 0.  This is used if IS_LARGE is false.  */

      unsigned HOST_WIDE_INT small_bitmask;

      struct

        {

          /* A bitmap with one bit per byte.  Cleared bit means the position

             is needed.  Used if IS_LARGE is false.  */

          bitmap bmap;

          /* Number of set bits (i.e. unneeded bytes) in BITMAP.  If it is

             equal to END - BEGIN, the whole store is unused.  */

          int count;

        } large;

    } positions_needed;

  /* The next store info for this insn.  */

  struct store_info *next;

  /* The right hand side of the store.  This is used if there is a

     subsequent reload of the mems address somewhere later in the

     basic block.  */

  rtx rhs;

  /* If rhs is or holds a constant, this contains that constant,

     otherwise NULL.  */

  rtx const_rhs;

  /* Set if this store stores the same constant value as REDUNDANT_REASON

     insn stored.  These aren't eliminated early, because doing that

     might prevent the earlier larger store to be eliminated.  */

  struct insn_info *redundant_reason;

};

/* Return a bitmask with the first N low bits set.  */

static unsigned HOST_WIDE_INT

lowpart_bitmask (int n)

{

  unsigned HOST_WIDE_INT mask = ~(unsigned HOST_WIDE_INT) 0;

  return mask >> (HOST_BITS_PER_WIDE_INT - n);

}

typedef struct store_info *store_info_t;

static alloc_pool cse_store_info_pool;

static alloc_pool rtx_store_info_pool;

/* This structure holds information about a load.  These are only

   built for rtx bases.  */

struct read_info

{

  /* The id of the mem group of the base address.  */

  int group_id;

  /* If this is non-zero, it is the alias set of a spill location.  */

  alias_set_type alias_set;

  /* The offset of the first and byte after the last byte associated

     with the operation.  If begin == end == 0, the read did not have

     a constant offset.  */

  int begin, end;

  /* The mem being read.  */

  rtx mem;

  /* The next read_info for this insn.  */

  struct read_info *next;

};

typedef struct read_info *read_info_t;

static alloc_pool read_info_pool;

/* One of these records is created for each insn.  */

struct insn_info

{

  /* Set true if the insn contains a store but the insn itself cannot

     be deleted.  This is set if the insn is a parallel and there is

     more than one non dead output or if the insn is in some way

     volatile.  */

  bool cannot_delete;

  /* This field is only used by the global algorithm.  It is set true

     if the insn contains any read of mem except for a (1).  This is

     also set if the insn is a call or has a clobber mem.  If the insn

     contains a wild read, the use_rec will be null.  */

  bool wild_read;

  /* This field is only used for the processing of const functions.

     These functions cannot read memory, but they can read the stack

     because that is where they may get their parms.  We need to be

     this conservative because, like the store motion pass, we don't

     consider CALL_INSN_FUNCTION_USAGE when processing call insns.

     Moreover, we need to distinguish two cases:

     1. Before reload (register elimination), the stores related to

        outgoing arguments are stack pointer based and thus deemed

        of non-constant base in this pass.  This requires special

        handling but also means that the frame pointer based stores

        need not be killed upon encountering a const function call.

     2. After reload, the stores related to outgoing arguments can be

        either stack pointer or hard frame pointer based.  This means

        that we have no other choice than also killing all the frame

        pointer based stores upon encountering a const function call.

     This field is set after reload for const function calls.  Having

     this set is less severe than a wild read, it just means that all

     the frame related stores are killed rather than all the stores.  */

  bool frame_read;

  /* This field is only used for the processing of const functions.

     It is set if the insn may contain a stack pointer based store.  */

  bool stack_pointer_based;

  /* This is true if any of the sets within the store contains a

     cselib base.  Such stores can only be deleted by the local

     algorithm.  */

  bool contains_cselib_groups;

  /* The insn. */

  rtx insn;

  /* The list of mem sets or mem clobbers that are contained in this

     insn.  If the insn is deletable, it contains only one mem set.

     But it could also contain clobbers.  Insns that contain more than

     one mem set are not deletable, but each of those mems are here in

     order to provide info to delete other insns.  */

  store_info_t store_rec;

  /* The linked list of mem uses in this insn.  Only the reads from

     rtx bases are listed here.  The reads to cselib bases are

     completely processed during the first scan and so are never

     created.  */

  read_info_t read_rec;

  /* The prev insn in the basic block.  */

  struct insn_info * prev_insn;

  /* The linked list of insns that are in consideration for removal in

     the forwards pass thru the basic block.  This pointer may be

     trash as it is not cleared when a wild read occurs.  The only

     time it is guaranteed to be correct is when the traversal starts

     at active_local_stores.  */

  struct insn_info * next_local_store;

};

typedef struct insn_info *insn_info_t;

static alloc_pool insn_info_pool;

/* The linked list of stores that are under consideration in this

   basic block.  */

static insn_info_t active_local_stores;

struct bb_info

{

  /* Pointer to the insn info for the last insn in the block.  These

     are linked so this is how all of the insns are reached.  During

     scanning this is the current insn being scanned.  */

  insn_info_t last_insn;

  /* The info for the global dataflow problem.  */

  /* This is set if the transfer function should and in the wild_read

     bitmap before applying the kill and gen sets.  That vector knocks

     out most of the bits in the bitmap and thus speeds up the

     operations.  */

  bool apply_wild_read;

  /* The following 4 bitvectors hold information about which positions

     of which stores are live or dead.  They are indexed by

     get_bitmap_index.  */

  /* The set of store positions that exist in this block before a wild read.  */

  bitmap gen;

  /* The set of load positions that exist in this block above the

     same position of a store.  */

  bitmap kill;

  /* The set of stores that reach the top of the block without being

     killed by a read.

     Do not represent the in if it is all ones.  Note that this is

     what the bitvector should logically be initialized to for a set

     intersection problem.  However, like the kill set, this is too

     expensive.  So initially, the in set will only be created for the

     exit block and any block that contains a wild read.  */

  bitmap in;

  /* The set of stores that reach the bottom of the block from it's

     successors.

     Do not represent the in if it is all ones.  Note that this is

     what the bitvector should logically be initialized to for a set

     intersection problem.  However, like the kill and in set, this is

     too expensive.  So what is done is that the confluence operator

     just initializes the vector from one of the out sets of the

     successors of the block.  */

  bitmap out;

  /* The following bitvector is indexed by the reg number.  It

     contains the set of regs that are live at the current instruction

     being processed.  While it contains info for all of the

     registers, only the pseudos are actually examined.  It is used to

     assure that shift sequences that are inserted do not accidently

     clobber live hard regs.  */

  bitmap regs_live;

};

typedef struct bb_info *bb_info_t;

static alloc_pool bb_info_pool;

/* Table to hold all bb_infos.  */

static bb_info_t *bb_table;

/* There is a group_info for each rtx base that is used to reference

   memory.  There are also not many of the rtx bases because they are

   very limited in scope.  */

struct group_info

{

  /* The actual base of the address.  */

  rtx rtx_base;

  /* The sequential id of the base.  This allows us to have a

     canonical ordering of these that is not based on addresses.  */

  int id;

  /* True if there are any positions that are to be processed

     globally.  */

  bool process_globally;

  /* True if the base of this group is either the frame_pointer or

     hard_frame_pointer.  */

  bool frame_related;

  /* A mem wrapped around the base pointer for the group in order to

     do read dependency.  */

  rtx base_mem;

  /* Canonized version of base_mem's address.  */

  rtx canon_base_addr;

  /* These two sets of two bitmaps are used to keep track of how many

     stores are actually referencing that position from this base.  We

     only do this for rtx bases as this will be used to assign

     positions in the bitmaps for the global problem.  Bit N is set in

     store1 on the first store for offset N.  Bit N is set in store2

     for the second store to offset N.  This is all we need since we

     only care about offsets that have two or more stores for them.

     The "_n" suffix is for offsets less than 0 and the "_p" suffix is

     for 0 and greater offsets.

     There is one special case here, for stores into the stack frame,

     we will or store1 into store2 before deciding which stores look

     at globally.  This is because stores to the stack frame that have

     no other reads before the end of the function can also be

     deleted.  */

  bitmap store1_n, store1_p, store2_n, store2_p;

  /* The positions in this bitmap have the same assignments as the in,

     out, gen and kill bitmaps.  This bitmap is all zeros except for

     the positions that are occupied by stores for this group.  */

  bitmap group_kill;

  /* The offset_map is used to map the offsets from this base into

     positions in the global bitmaps.  It is only created after all of

     the all of stores have been scanned and we know which ones we

     care about.  */

  int *offset_map_n, *offset_map_p;

  int offset_map_size_n, offset_map_size_p;

};

typedef struct group_info *group_info_t;

typedef const struct group_info *const_group_info_t;

static alloc_pool rtx_group_info_pool;

/* Tables of group_info structures, hashed by base value.  */

static htab_t rtx_group_table;

/* Index into the rtx_group_vec.  */

static int rtx_group_next_id;

DEF_VEC_P(group_info_t);

DEF_VEC_ALLOC_P(group_info_t,heap);

static VEC(group_info_t,heap) *rtx_group_vec;

/* This structure holds the set of changes that are being deferred

   when removing read operation.  See replace_read.  */

struct deferred_change

{

  /* The mem that is being replaced.  */

  rtx *loc;

  /* The reg it is being replaced with.  */

  rtx reg;

  struct deferred_change *next;

};

typedef struct deferred_change *deferred_change_t;

static alloc_pool deferred_change_pool;

static deferred_change_t deferred_change_list = NULL;

/* This are used to hold the alias sets of spill variables.  Since

   these are never aliased and there may be a lot of them, it makes

   sense to treat them specially.  This bitvector is only allocated in

   calls from dse_record_singleton_alias_set which currently is only

   made during reload1.  So when dse is called before reload this

   mechanism does nothing.  */

static bitmap clear_alias_sets = NULL;

/* The set of clear_alias_sets that have been disqualified because

   there are loads or stores using a different mode than the alias set

   was registered with.  */

static bitmap disqualified_clear_alias_sets = NULL;

/* The group that holds all of the clear_alias_sets.  */

static group_info_t clear_alias_group;

/* The modes of the clear_alias_sets.  */

static htab_t clear_alias_mode_table;

/* Hash table element to look up the mode for an alias set.  */

struct clear_alias_mode_holder

{

  alias_set_type alias_set;

  enum machine_mode mode;

};

static alloc_pool clear_alias_mode_pool;

/* This is true except if cfun->stdarg -- i.e. we cannot do

   this for vararg functions because they play games with the frame.  */

static bool stores_off_frame_dead_at_return;

/* Counter for stats.  */

static int globally_deleted;

static int locally_deleted;

static int spill_deleted;

static bitmap all_blocks;

/* The number of bits used in the global bitmaps.  */

static unsigned int current_position;

static bool gate_dse (void);

static bool gate_dse1 (void);

static bool gate_dse2 (void);

/*----------------------------------------------------------------------------

   Zeroth step.

   Initialization.

----------------------------------------------------------------------------*/

/* Hashtable callbacks for maintaining the "bases" field of

   store_group_info, given that the addresses are function invariants.  */

static int

clear_alias_mode_eq (const void *p1, const void *p2)

{

  const struct clear_alias_mode_holder * h1

    = (const struct clear_alias_mode_holder *) p1;

  const struct clear_alias_mode_holder * h2

    = (const struct clear_alias_mode_holder *) p2;

  return h1->alias_set == h2->alias_set;

}

static hashval_t

clear_alias_mode_hash (const void *p)

{

  const struct clear_alias_mode_holder *holder

    = (const struct clear_alias_mode_holder *) p;

  return holder->alias_set;

}

/* Find the entry associated with ALIAS_SET.  */

static struct clear_alias_mode_holder *

clear_alias_set_lookup (alias_set_type alias_set)

{

  struct clear_alias_mode_holder tmp_holder;

  void **slot;

  tmp_holder.alias_set = alias_set;

  slot = htab_find_slot (clear_alias_mode_table, &tmp_holder, NO_INSERT);

  gcc_assert (*slot);

  return (struct clear_alias_mode_holder *) *slot;

}

/* Hashtable callbacks for maintaining the "bases" field of

   store_group_info, given that the addresses are function invariants.  */

static int

invariant_group_base_eq (const void *p1, const void *p2)

{

  const_group_info_t gi1 = (const_group_info_t) p1;

  const_group_info_t gi2 = (const_group_info_t) p2;

  return rtx_equal_p (gi1->rtx_base, gi2->rtx_base);

}

static hashval_t

invariant_group_base_hash (const void *p)

{

  const_group_info_t gi = (const_group_info_t) p;

  int do_not_record;

  return hash_rtx (gi->rtx_base, Pmode, &do_not_record, NULL, false);

}

/* Get the GROUP for BASE.  Add a new group if it is not there.  */

static group_info_t

get_group_info (rtx base)

{

  struct group_info tmp_gi;

  group_info_t gi;

  void **slot;

  if (base)

    {

      /* Find the store_base_info structure for BASE, creating a new one

         if necessary.  */

      tmp_gi.rtx_base = base;

      slot = htab_find_slot (rtx_group_table, &tmp_gi, INSERT);

      gi = (group_info_t) *slot;

    }

  else

    {

      if (!clear_alias_group)

        {

          clear_alias_group = gi =

            (group_info_t) pool_alloc (rtx_group_info_pool);

          memset (gi, 0, sizeof (struct group_info));

          gi->id = rtx_group_next_id++;

          gi->store1_n = BITMAP_ALLOC (NULL);

          gi->store1_p = BITMAP_ALLOC (NULL);

          gi->store2_n = BITMAP_ALLOC (NULL);

          gi->store2_p = BITMAP_ALLOC (NULL);

          gi->group_kill = BITMAP_ALLOC (NULL);

          gi->process_globally = false;

          gi->offset_map_size_n = 0;

          gi->offset_map_size_p = 0;

          gi->offset_map_n = NULL;

          gi->offset_map_p = NULL;

          VEC_safe_push (group_info_t, heap, rtx_group_vec, gi);

        }

      return clear_alias_group;

    }

  if (gi == NULL)

    {

      *slot = gi = (group_info_t) pool_alloc (rtx_group_info_pool);

      gi->rtx_base = base;

      gi->id = rtx_group_next_id++;

      gi->base_mem = gen_rtx_MEM (QImode, base);

      gi->canon_base_addr = canon_rtx (base);

      gi->store1_n = BITMAP_ALLOC (NULL);

      gi->store1_p = BITMAP_ALLOC (NULL);

      gi->store2_n = BITMAP_ALLOC (NULL);

      gi->store2_p = BITMAP_ALLOC (NULL);

      gi->group_kill = BITMAP_ALLOC (NULL);

      gi->process_globally = false;

      gi->frame_related =

        (base == frame_pointer_rtx) || (base == hard_frame_pointer_rtx);

      gi->offset_map_size_n = 0;

      gi->offset_map_size_p = 0;

      gi->offset_map_n = NULL;

      gi->offset_map_p = NULL;

      VEC_safe_push (group_info_t, heap, rtx_group_vec, gi);

    }

  return gi;

}

/* Initialization of data structures.  */

static void

dse_step0 (void)

{

  locally_deleted = 0;

  globally_deleted = 0;

  spill_deleted = 0;

  scratch = BITMAP_ALLOC (NULL);

  rtx_store_info_pool

    = create_alloc_pool ("rtx_store_info_pool",

                         sizeof (struct store_info), 100);

  read_info_pool

    = create_alloc_pool ("read_info_pool",

                         sizeof (struct read_info), 100);

  insn_info_pool

    = create_alloc_pool ("insn_info_pool",

                         sizeof (struct insn_info), 100);

  bb_info_pool

    = create_alloc_pool ("bb_info_pool",

                         sizeof (struct bb_info), 100);

  rtx_group_info_pool

    = create_alloc_pool ("rtx_group_info_pool",

                         sizeof (struct group_info), 100);

  deferred_change_pool

    = create_alloc_pool ("deferred_change_pool",

                         sizeof (struct deferred_change), 10);

  rtx_group_table = htab_create (11, invariant_group_base_hash,

                                 invariant_group_base_eq, NULL);

  bb_table = XCNEWVEC (bb_info_t, last_basic_block);

  rtx_group_next_id = 0;

  stores_off_frame_dead_at_return = !cfun->stdarg;

  init_alias_analysis ();

  if (clear_alias_sets)

    clear_alias_group = get_group_info (NULL);

  else

    clear_alias_group = NULL;

}

/*----------------------------------------------------------------------------

   First step.

   Scan all of the insns.  Any random ordering of the blocks is fine.

   Each block is scanned in forward order to accommodate cselib which

   is used to remove stores with non-constant bases.

----------------------------------------------------------------------------*/

/* Delete all of the store_info recs from INSN_INFO.  */

static void

free_store_info (insn_info_t insn_info)

{

  store_info_t store_info = insn_info->store_rec;

  while (store_info)

    {

      store_info_t next = store_info->next;

      if (store_info->is_large)

        BITMAP_FREE (store_info->positions_needed.large.bmap);

      if (store_info->cse_base)

        pool_free (cse_store_info_pool, store_info);

      else

        pool_free (rtx_store_info_pool, store_info);

      store_info = next;

    }

  insn_info->cannot_delete = true;

  insn_info->contains_cselib_groups = false;

  insn_info->store_rec = NULL;

}