Subversion Repositories openrisc

/* Optimize by combining instructions for GNU compiler.

   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

   2011, 2012 Free Software Foundation, Inc.

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/>.  */

/* This module is essentially the "combiner" phase of the U. of Arizona

   Portable Optimizer, but redone to work on our list-structured

   representation for RTL instead of their string representation.

   The LOG_LINKS of each insn identify the most recent assignment

   to each REG used in the insn.  It is a list of previous insns,

   each of which contains a SET for a REG that is used in this insn

   and not used or set in between.  LOG_LINKs never cross basic blocks.

   They were set up by the preceding pass (lifetime analysis).

   We try to combine each pair of insns joined by a logical link.

   We also try to combine triples of insns A, B and C when

   C has a link back to B and B has a link back to A.

   LOG_LINKS does not have links for use of the CC0.  They don't

   need to, because the insn that sets the CC0 is always immediately

   before the insn that tests it.  So we always regard a branch

   insn as having a logical link to the preceding insn.  The same is true

   for an insn explicitly using CC0.

   We check (with use_crosses_set_p) to avoid combining in such a way

   as to move a computation to a place where its value would be different.

   Combination is done by mathematically substituting the previous

   insn(s) values for the regs they set into the expressions in

   the later insns that refer to these regs.  If the result is a valid insn

   for our target machine, according to the machine description,

   we install it, delete the earlier insns, and update the data flow

   information (LOG_LINKS and REG_NOTES) for what we did.

   There are a few exceptions where the dataflow information isn't

   completely updated (however this is only a local issue since it is

   regenerated before the next pass that uses it):

   - reg_live_length is not updated

   - reg_n_refs is not adjusted in the rare case when a register is

     no longer required in a computation

   - there are extremely rare cases (see distribute_notes) when a

     REG_DEAD note is lost

   - a LOG_LINKS entry that refers to an insn with multiple SETs may be

     removed because there is no way to know which register it was

     linking

   To simplify substitution, we combine only when the earlier insn(s)

   consist of only a single assignment.  To simplify updating afterward,

   we never combine when a subroutine call appears in the middle.

   Since we do not represent assignments to CC0 explicitly except when that

   is all an insn does, there is no LOG_LINKS entry in an insn that uses

   the condition code for the insn that set the condition code.

   Fortunately, these two insns must be consecutive.

   Therefore, every JUMP_INSN is taken to have an implicit logical link

   to the preceding insn.  This is not quite right, since non-jumps can

   also use the condition code; but in practice such insns would not

   combine anyway.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "tm_p.h"

#include "flags.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "insn-config.h"

#include "function.h"

/* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */

#include "expr.h"

#include "insn-attr.h"

#include "recog.h"

#include "diagnostic-core.h"

#include "target.h"

#include "optabs.h"

#include "insn-codes.h"

#include "rtlhooks-def.h"

/* Include output.h for dump_file.  */

#include "output.h"

#include "params.h"

#include "timevar.h"

#include "tree-pass.h"

#include "df.h"

#include "cgraph.h"

#include "obstack.h"

/* Number of attempts to combine instructions in this function.  */

static int combine_attempts;

/* Number of attempts that got as far as substitution in this function.  */

static int combine_merges;

/* Number of instructions combined with added SETs in this function.  */

static int combine_extras;

/* Number of instructions combined in this function.  */

static int combine_successes;

/* Totals over entire compilation.  */

static int total_attempts, total_merges, total_extras, total_successes;

/* combine_instructions may try to replace the right hand side of the

   second instruction with the value of an associated REG_EQUAL note

   before throwing it at try_combine.  That is problematic when there

   is a REG_DEAD note for a register used in the old right hand side

   and can cause distribute_notes to do wrong things.  This is the

   second instruction if it has been so modified, null otherwise.  */

static rtx i2mod;

/* When I2MOD is nonnull, this is a copy of the old right hand side.  */

static rtx i2mod_old_rhs;

/* When I2MOD is nonnull, this is a copy of the new right hand side.  */

static rtx i2mod_new_rhs;

typedef struct reg_stat_struct {

  /* Record last point of death of (hard or pseudo) register n.  */

  rtx                           last_death;

  /* Record last point of modification of (hard or pseudo) register n.  */

  rtx                           last_set;

  /* The next group of fields allows the recording of the last value assigned

     to (hard or pseudo) register n.  We use this information to see if an

     operation being processed is redundant given a prior operation performed

     on the register.  For example, an `and' with a constant is redundant if

     all the zero bits are already known to be turned off.

     We use an approach similar to that used by cse, but change it in the

     following ways:

     (1) We do not want to reinitialize at each label.

     (2) It is useful, but not critical, to know the actual value assigned

         to a register.  Often just its form is helpful.

     Therefore, we maintain the following fields:

     last_set_value             the last value assigned

     last_set_label             records the value of label_tick when the

                                register was assigned

     last_set_table_tick        records the value of label_tick when a

                                value using the register is assigned

     last_set_invalid           set to nonzero when it is not valid

                                to use the value of this register in some

                                register's value

     To understand the usage of these tables, it is important to understand

     the distinction between the value in last_set_value being valid and

     the register being validly contained in some other expression in the

     table.

     (The next two parameters are out of date).

     reg_stat[i].last_set_value is valid if it is nonzero, and either

     reg_n_sets[i] is 1 or reg_stat[i].last_set_label == label_tick.

     Register I may validly appear in any expression returned for the value

     of another register if reg_n_sets[i] is 1.  It may also appear in the

     value for register J if reg_stat[j].last_set_invalid is zero, or

     reg_stat[i].last_set_label < reg_stat[j].last_set_label.

     If an expression is found in the table containing a register which may

     not validly appear in an expression, the register is replaced by

     something that won't match, (clobber (const_int 0)).  */

  /* Record last value assigned to (hard or pseudo) register n.  */

  rtx                           last_set_value;

  /* Record the value of label_tick when an expression involving register n

     is placed in last_set_value.  */

  int                           last_set_table_tick;

  /* Record the value of label_tick when the value for register n is placed in

     last_set_value.  */

  int                           last_set_label;

  /* These fields are maintained in parallel with last_set_value and are

     used to store the mode in which the register was last set, the bits

     that were known to be zero when it was last set, and the number of

     sign bits copies it was known to have when it was last set.  */

  unsigned HOST_WIDE_INT        last_set_nonzero_bits;

  char                          last_set_sign_bit_copies;

  ENUM_BITFIELD(machine_mode)   last_set_mode : 8;

  /* Set nonzero if references to register n in expressions should not be

     used.  last_set_invalid is set nonzero when this register is being

     assigned to and last_set_table_tick == label_tick.  */

  char                          last_set_invalid;

  /* Some registers that are set more than once and used in more than one

     basic block are nevertheless always set in similar ways.  For example,

     a QImode register may be loaded from memory in two places on a machine

     where byte loads zero extend.

     We record in the following fields if a register has some leading bits

     that are always equal to the sign bit, and what we know about the

     nonzero bits of a register, specifically which bits are known to be

     zero.

     If an entry is zero, it means that we don't know anything special.  */

  unsigned char                 sign_bit_copies;

  unsigned HOST_WIDE_INT        nonzero_bits;

  /* Record the value of the label_tick when the last truncation

     happened.  The field truncated_to_mode is only valid if

     truncation_label == label_tick.  */

  int                           truncation_label;

  /* Record the last truncation seen for this register.  If truncation

     is not a nop to this mode we might be able to save an explicit

     truncation if we know that value already contains a truncated

     value.  */

  ENUM_BITFIELD(machine_mode)   truncated_to_mode : 8;

} reg_stat_type;

DEF_VEC_O(reg_stat_type);

DEF_VEC_ALLOC_O(reg_stat_type,heap);

static VEC(reg_stat_type,heap) *reg_stat;

/* Record the luid of the last insn that invalidated memory

   (anything that writes memory, and subroutine calls, but not pushes).  */

static int mem_last_set;

/* Record the luid of the last CALL_INSN

   so we can tell whether a potential combination crosses any calls.  */

static int last_call_luid;

/* When `subst' is called, this is the insn that is being modified

   (by combining in a previous insn).  The PATTERN of this insn

   is still the old pattern partially modified and it should not be

   looked at, but this may be used to examine the successors of the insn

   to judge whether a simplification is valid.  */

static rtx subst_insn;

/* This is the lowest LUID that `subst' is currently dealing with.

   get_last_value will not return a value if the register was set at or

   after this LUID.  If not for this mechanism, we could get confused if

   I2 or I1 in try_combine were an insn that used the old value of a register

   to obtain a new value.  In that case, we might erroneously get the

   new value of the register when we wanted the old one.  */

static int subst_low_luid;

/* This contains any hard registers that are used in newpat; reg_dead_at_p

   must consider all these registers to be always live.  */

static HARD_REG_SET newpat_used_regs;

/* This is an insn to which a LOG_LINKS entry has been added.  If this

   insn is the earlier than I2 or I3, combine should rescan starting at

   that location.  */

static rtx added_links_insn;

/* Basic block in which we are performing combines.  */

static basic_block this_basic_block;

static bool optimize_this_for_speed_p;

/* Length of the currently allocated uid_insn_cost array.  */

static int max_uid_known;

/* The following array records the insn_rtx_cost for every insn

   in the instruction stream.  */

static int *uid_insn_cost;

/* The following array records the LOG_LINKS for every insn in the

   instruction stream as struct insn_link pointers.  */

struct insn_link {

  rtx insn;

  struct insn_link *next;

};

static struct insn_link **uid_log_links;

#define INSN_COST(INSN)         (uid_insn_cost[INSN_UID (INSN)])

#define LOG_LINKS(INSN)         (uid_log_links[INSN_UID (INSN)])

#define FOR_EACH_LOG_LINK(L, INSN)                              \

  for ((L) = LOG_LINKS (INSN); (L); (L) = (L)->next)

/* Links for LOG_LINKS are allocated from this obstack.  */

static struct obstack insn_link_obstack;

/* Allocate a link.  */

static inline struct insn_link *

alloc_insn_link (rtx insn, struct insn_link *next)

{

  struct insn_link *l

    = (struct insn_link *) obstack_alloc (&insn_link_obstack,

                                          sizeof (struct insn_link));

  l->insn = insn;

  l->next = next;

  return l;

}

/* Incremented for each basic block.  */

static int label_tick;

/* Reset to label_tick for each extended basic block in scanning order.  */

static int label_tick_ebb_start;

/* Mode used to compute significance in reg_stat[].nonzero_bits.  It is the

   largest integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */

static enum machine_mode nonzero_bits_mode;

/* Nonzero when reg_stat[].nonzero_bits and reg_stat[].sign_bit_copies can

   be safely used.  It is zero while computing them and after combine has

   completed.  This former test prevents propagating values based on

   previously set values, which can be incorrect if a variable is modified

   in a loop.  */

static int nonzero_sign_valid;

/* Record one modification to rtl structure

   to be undone by storing old_contents into *where.  */

enum undo_kind { UNDO_RTX, UNDO_INT, UNDO_MODE, UNDO_LINKS };

struct undo

{

  struct undo *next;

  enum undo_kind kind;

  union { rtx r; int i; enum machine_mode m; struct insn_link *l; } old_contents;

  union { rtx *r; int *i; struct insn_link **l; } where;

};

/* Record a bunch of changes to be undone, up to MAX_UNDO of them.

   num_undo says how many are currently recorded.

   other_insn is nonzero if we have modified some other insn in the process

   of working on subst_insn.  It must be verified too.  */

struct undobuf

{

  struct undo *undos;

  struct undo *frees;

  rtx other_insn;

};

static struct undobuf undobuf;

/* Number of times the pseudo being substituted for

   was found and replaced.  */

static int n_occurrences;

static rtx reg_nonzero_bits_for_combine (const_rtx, enum machine_mode, const_rtx,

                                         enum machine_mode,

                                         unsigned HOST_WIDE_INT,

                                         unsigned HOST_WIDE_INT *);

static rtx reg_num_sign_bit_copies_for_combine (const_rtx, enum machine_mode, const_rtx,

                                                enum machine_mode,

                                                unsigned int, unsigned int *);

static void do_SUBST (rtx *, rtx);

static void do_SUBST_INT (int *, int);

static void init_reg_last (void);

static void setup_incoming_promotions (rtx);

static void set_nonzero_bits_and_sign_copies (rtx, const_rtx, void *);

static int cant_combine_insn_p (rtx);

static int can_combine_p (rtx, rtx, rtx, rtx, rtx, rtx, rtx *, rtx *);

static int combinable_i3pat (rtx, rtx *, rtx, rtx, rtx, int, int, rtx *);

static int contains_muldiv (rtx);

static rtx try_combine (rtx, rtx, rtx, rtx, int *, rtx);

static void undo_all (void);

static void undo_commit (void);

static rtx *find_split_point (rtx *, rtx, bool);

static rtx subst (rtx, rtx, rtx, int, int, int);

static rtx combine_simplify_rtx (rtx, enum machine_mode, int, int);

static rtx simplify_if_then_else (rtx);

static rtx simplify_set (rtx);

static rtx simplify_logical (rtx);

static rtx expand_compound_operation (rtx);

static const_rtx expand_field_assignment (const_rtx);

static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,

                            rtx, unsigned HOST_WIDE_INT, int, int, int);

static rtx extract_left_shift (rtx, int);

static rtx make_compound_operation (rtx, enum rtx_code);

static int get_pos_from_mask (unsigned HOST_WIDE_INT,

                              unsigned HOST_WIDE_INT *);

static rtx canon_reg_for_combine (rtx, rtx);

static rtx force_to_mode (rtx, enum machine_mode,

                          unsigned HOST_WIDE_INT, int);

static rtx if_then_else_cond (rtx, rtx *, rtx *);

static rtx known_cond (rtx, enum rtx_code, rtx, rtx);

static int rtx_equal_for_field_assignment_p (rtx, rtx);

static rtx make_field_assignment (rtx);

static rtx apply_distributive_law (rtx);

static rtx distribute_and_simplify_rtx (rtx, int);

static rtx simplify_and_const_int_1 (enum machine_mode, rtx,

                                     unsigned HOST_WIDE_INT);

static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,

                                   unsigned HOST_WIDE_INT);

static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,

                            HOST_WIDE_INT, enum machine_mode, int *);

static rtx simplify_shift_const_1 (enum rtx_code, enum machine_mode, rtx, int);

static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,

                                 int);

static int recog_for_combine (rtx *, rtx, rtx *);

static rtx gen_lowpart_for_combine (enum machine_mode, rtx);

static enum rtx_code simplify_compare_const (enum rtx_code, rtx, rtx *);

static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);

static void update_table_tick (rtx);

static void record_value_for_reg (rtx, rtx, rtx);

static void check_promoted_subreg (rtx, rtx);

static void record_dead_and_set_regs_1 (rtx, const_rtx, void *);

static void record_dead_and_set_regs (rtx);

static int get_last_value_validate (rtx *, rtx, int, int);

static rtx get_last_value (const_rtx);

static int use_crosses_set_p (const_rtx, int);

static void reg_dead_at_p_1 (rtx, const_rtx, void *);

static int reg_dead_at_p (rtx, rtx);

static void move_deaths (rtx, rtx, int, rtx, rtx *);

static int reg_bitfield_target_p (rtx, rtx);

static void distribute_notes (rtx, rtx, rtx, rtx, rtx, rtx, rtx);

static void distribute_links (struct insn_link *);

static void mark_used_regs_combine (rtx);

static void record_promoted_value (rtx, rtx);

static int unmentioned_reg_p_1 (rtx *, void *);

static bool unmentioned_reg_p (rtx, rtx);

static int record_truncated_value (rtx *, void *);

static void record_truncated_values (rtx *, void *);

static bool reg_truncated_to_mode (enum machine_mode, const_rtx);

static rtx gen_lowpart_or_truncate (enum machine_mode, rtx);

/* It is not safe to use ordinary gen_lowpart in combine.

   See comments in gen_lowpart_for_combine.  */

#undef RTL_HOOKS_GEN_LOWPART

#define RTL_HOOKS_GEN_LOWPART              gen_lowpart_for_combine

/* Our implementation of gen_lowpart never emits a new pseudo.  */

#undef RTL_HOOKS_GEN_LOWPART_NO_EMIT

#define RTL_HOOKS_GEN_LOWPART_NO_EMIT      gen_lowpart_for_combine

#undef RTL_HOOKS_REG_NONZERO_REG_BITS

#define RTL_HOOKS_REG_NONZERO_REG_BITS     reg_nonzero_bits_for_combine

#undef RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES

#define RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES  reg_num_sign_bit_copies_for_combine

#undef RTL_HOOKS_REG_TRUNCATED_TO_MODE

#define RTL_HOOKS_REG_TRUNCATED_TO_MODE    reg_truncated_to_mode

static const struct rtl_hooks combine_rtl_hooks = RTL_HOOKS_INITIALIZER;

/* Try to split PATTERN found in INSN.  This returns NULL_RTX if

   PATTERN can not be split.  Otherwise, it returns an insn sequence.

   This is a wrapper around split_insns which ensures that the

   reg_stat vector is made larger if the splitter creates a new

   register.  */

static rtx

combine_split_insns (rtx pattern, rtx insn)

{

  rtx ret;

  unsigned int nregs;

  ret = split_insns (pattern, insn);

  nregs = max_reg_num ();

  if (nregs > VEC_length (reg_stat_type, reg_stat))

    VEC_safe_grow_cleared (reg_stat_type, heap, reg_stat, nregs);

  return ret;

}

/* This is used by find_single_use to locate an rtx in LOC that

   contains exactly one use of DEST, which is typically either a REG

   or CC0.  It returns a pointer to the innermost rtx expression

   containing DEST.  Appearances of DEST that are being used to

   totally replace it are not counted.  */

static rtx *

find_single_use_1 (rtx dest, rtx *loc)

{

  rtx x = *loc;

  enum rtx_code code = GET_CODE (x);

  rtx *result = NULL;

  rtx *this_result;

  int i;

  const char *fmt;

  switch (code)

    {

    case CONST_INT:

    case CONST:

    case LABEL_REF:

    case SYMBOL_REF:

    case CONST_DOUBLE:

    case CONST_VECTOR:

    case CLOBBER:

      return 0;

    case SET:

      /* If the destination is anything other than CC0, PC, a REG or a SUBREG

         of a REG that occupies all of the REG, the insn uses DEST if

         it is mentioned in the destination or the source.  Otherwise, we

         need just check the source.  */

      if (GET_CODE (SET_DEST (x)) != CC0

          && GET_CODE (SET_DEST (x)) != PC

          && !REG_P (SET_DEST (x))

          && ! (GET_CODE (SET_DEST (x)) == SUBREG

                && REG_P (SUBREG_REG (SET_DEST (x)))

                && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))

                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)

                    == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))

                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))

        break;

      return find_single_use_1 (dest, &SET_SRC (x));

    case MEM:

    case SUBREG:

      return find_single_use_1 (dest, &XEXP (x, 0));

    default:

      break;

    }

  /* If it wasn't one of the common cases above, check each expression and

     vector of this code.  Look for a unique usage of DEST.  */

  fmt = GET_RTX_FORMAT (code);

  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)

    {

      if (fmt[i] == 'e')

        {

          if (dest == XEXP (x, i)

              || (REG_P (dest) && REG_P (XEXP (x, i))

                  && REGNO (dest) == REGNO (XEXP (x, i))))

            this_result = loc;

          else

            this_result = find_single_use_1 (dest, &XEXP (x, i));

          if (result == NULL)

            result = this_result;

          else if (this_result)

            /* Duplicate usage.  */

            return NULL;

        }

      else if (fmt[i] == 'E')

        {

          int j;

          for (j = XVECLEN (x, i) - 1; j >= 0; j--)

            {

              if (XVECEXP (x, i, j) == dest

                  || (REG_P (dest)

                      && REG_P (XVECEXP (x, i, j))

                      && REGNO (XVECEXP (x, i, j)) == REGNO (dest)))

                this_result = loc;

              else

                this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));

              if (result == NULL)

                result = this_result;

              else if (this_result)

                return NULL;

            }

        }

    }

  return result;

}

/* See if DEST, produced in INSN, is used only a single time in the

   sequel.  If so, return a pointer to the innermost rtx expression in which

   it is used.

   If PLOC is nonzero, *PLOC is set to the insn containing the single use.

   If DEST is cc0_rtx, we look only at the next insn.  In that case, we don't

   care about REG_DEAD notes or LOG_LINKS.

   Otherwise, we find the single use by finding an insn that has a

   LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST.  If DEST is

   only referenced once in that insn, we know that it must be the first

   and last insn referencing DEST.  */

static rtx *

find_single_use (rtx dest, rtx insn, rtx *ploc)

{

  basic_block bb;

  rtx next;

  rtx *result;

  struct insn_link *link;

#ifdef HAVE_cc0

  if (dest == cc0_rtx)

    {

      next = NEXT_INSN (insn);

      if (next == 0

          || (!NONJUMP_INSN_P (next) && !JUMP_P (next)))

        return 0;

      result = find_single_use_1 (dest, &PATTERN (next));

      if (result && ploc)

        *ploc = next;

      return result;

    }

#endif

  if (!REG_P (dest))

    return 0;

  bb = BLOCK_FOR_INSN (insn);

  for (next = NEXT_INSN (insn);

       next && BLOCK_FOR_INSN (next) == bb;

       next = NEXT_INSN (next))

    if (INSN_P (next) && dead_or_set_p (next, dest))

      {

        FOR_EACH_LOG_LINK (link, next)

          if (link->insn == insn)

            break;

        if (link)

          {

            result = find_single_use_1 (dest, &PATTERN (next));

            if (ploc)

              *ploc = next;

            return result;

          }

      }

  return 0;

}

/* Substitute NEWVAL, an rtx expression, into INTO, a place in some

   insn.  The substitution can be undone by undo_all.  If INTO is already

   set to NEWVAL, do not record this change.  Because computing NEWVAL might

   also call SUBST, we have to compute it before we put anything into

   the undo table.  */

static void

do_SUBST (rtx *into, rtx newval)

{

  struct undo *buf;

  rtx oldval = *into;

  if (oldval == newval)

    return;

  /* We'd like to catch as many invalid transformations here as

     possible.  Unfortunately, there are way too many mode changes

     that are perfectly valid, so we'd waste too much effort for

     little gain doing the checks here.  Focus on catching invalid

     transformations involving integer constants.  */

  if (GET_MODE_CLASS (GET_MODE (oldval)) == MODE_INT

      && CONST_INT_P (newval))

    {

      /* Sanity check that we're replacing oldval with a CONST_INT

         that is a valid sign-extension for the original mode.  */

      gcc_assert (INTVAL (newval)

                  == trunc_int_for_mode (INTVAL (newval), GET_MODE (oldval)));

      /* Replacing the operand of a SUBREG or a ZERO_EXTEND with a

         CONST_INT is not valid, because after the replacement, the

         original mode would be gone.  Unfortunately, we can't tell

         when do_SUBST is called to replace the operand thereof, so we

         perform this test on oldval instead, checking whether an

         invalid replacement took place before we got here.  */

      gcc_assert (!(GET_CODE (oldval) == SUBREG

                    && CONST_INT_P (SUBREG_REG (oldval))));

      gcc_assert (!(GET_CODE (oldval) == ZERO_EXTEND

                    && CONST_INT_P (XEXP (oldval, 0))));

    }

  if (undobuf.frees)

    buf = undobuf.frees, undobuf.frees = buf->next;

  else

    buf = XNEW (struct undo);

  buf->kind = UNDO_RTX;

  buf->where.r = into;

  buf->old_contents.r = oldval;

  *into = newval;

  buf->next = undobuf.undos, undobuf.undos = buf;

}