Subversion Repositories openrisc

/* Decompose multiword subregs.

   Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.

   Contributed by Richard Henderson <rth@redhat.com>

                  Ian Lance Taylor <iant@google.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/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "machmode.h"

#include "tm.h"

#include "rtl.h"

#include "tm_p.h"

#include "timevar.h"

#include "flags.h"

#include "insn-config.h"

#include "obstack.h"

#include "basic-block.h"

#include "recog.h"

#include "bitmap.h"

#include "expr.h"

#include "except.h"

#include "regs.h"

#include "tree-pass.h"

#include "df.h"

#ifdef STACK_GROWS_DOWNWARD

# undef STACK_GROWS_DOWNWARD

# define STACK_GROWS_DOWNWARD 1

#else

# define STACK_GROWS_DOWNWARD 0

#endif

DEF_VEC_P (bitmap);

DEF_VEC_ALLOC_P (bitmap,heap);

/* Decompose multi-word pseudo-registers into individual

   pseudo-registers when possible.  This is possible when all the uses

   of a multi-word register are via SUBREG, or are copies of the

   register to another location.  Breaking apart the register permits

   more CSE and permits better register allocation.  */

/* Bit N in this bitmap is set if regno N is used in a context in

   which we can decompose it.  */

static bitmap decomposable_context;

/* Bit N in this bitmap is set if regno N is used in a context in

   which it can not be decomposed.  */

static bitmap non_decomposable_context;

/* Bit N in the bitmap in element M of this array is set if there is a

   copy from reg M to reg N.  */

static VEC(bitmap,heap) *reg_copy_graph;

/* Return whether X is a simple object which we can take a word_mode

   subreg of.  */

static bool

simple_move_operand (rtx x)

{

  if (GET_CODE (x) == SUBREG)

    x = SUBREG_REG (x);

  if (!OBJECT_P (x))

    return false;

  if (GET_CODE (x) == LABEL_REF

      || GET_CODE (x) == SYMBOL_REF

      || GET_CODE (x) == HIGH

      || GET_CODE (x) == CONST)

    return false;

  if (MEM_P (x)

      && (MEM_VOLATILE_P (x)

          || mode_dependent_address_p (XEXP (x, 0))))

    return false;

  return true;

}

/* If INSN is a single set between two objects, return the single set.

   Such an insn can always be decomposed.  INSN should have been

   passed to recog and extract_insn before this is called.  */

static rtx

simple_move (rtx insn)

{

  rtx x;

  rtx set;

  enum machine_mode mode;

  if (recog_data.n_operands != 2)

    return NULL_RTX;

  set = single_set (insn);

  if (!set)

    return NULL_RTX;

  x = SET_DEST (set);

  if (x != recog_data.operand[0] && x != recog_data.operand[1])

    return NULL_RTX;

  if (!simple_move_operand (x))

    return NULL_RTX;

  x = SET_SRC (set);

  if (x != recog_data.operand[0] && x != recog_data.operand[1])

    return NULL_RTX;

  /* For the src we can handle ASM_OPERANDS, and it is beneficial for

     things like x86 rdtsc which returns a DImode value.  */

  if (GET_CODE (x) != ASM_OPERANDS

      && !simple_move_operand (x))

    return NULL_RTX;

  /* We try to decompose in integer modes, to avoid generating

     inefficient code copying between integer and floating point

     registers.  That means that we can't decompose if this is a

     non-integer mode for which there is no integer mode of the same

     size.  */

  mode = GET_MODE (SET_SRC (set));

  if (!SCALAR_INT_MODE_P (mode)

      && (mode_for_size (GET_MODE_SIZE (mode) * BITS_PER_UNIT, MODE_INT, 0)

          == BLKmode))

    return NULL_RTX;

  /* Reject PARTIAL_INT modes.  They are used for processor specific

     purposes and it's probably best not to tamper with them.  */

  if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)

    return NULL_RTX;

  return set;

}

/* If SET is a copy from one multi-word pseudo-register to another,

   record that in reg_copy_graph.  Return whether it is such a

   copy.  */

static bool

find_pseudo_copy (rtx set)

{

  rtx dest = SET_DEST (set);

  rtx src = SET_SRC (set);

  unsigned int rd, rs;

  bitmap b;

  if (!REG_P (dest) || !REG_P (src))

    return false;

  rd = REGNO (dest);

  rs = REGNO (src);

  if (HARD_REGISTER_NUM_P (rd) || HARD_REGISTER_NUM_P (rs))

    return false;

  if (GET_MODE_SIZE (GET_MODE (dest)) <= UNITS_PER_WORD)

    return false;

  b = VEC_index (bitmap, reg_copy_graph, rs);

  if (b == NULL)

    {

      b = BITMAP_ALLOC (NULL);

      VEC_replace (bitmap, reg_copy_graph, rs, b);

    }

  bitmap_set_bit (b, rd);

  return true;

}

/* Look through the registers in DECOMPOSABLE_CONTEXT.  For each case

   where they are copied to another register, add the register to

   which they are copied to DECOMPOSABLE_CONTEXT.  Use

   NON_DECOMPOSABLE_CONTEXT to limit this--we don't bother to track

   copies of registers which are in NON_DECOMPOSABLE_CONTEXT.  */

static void

propagate_pseudo_copies (void)

{

  bitmap queue, propagate;

  queue = BITMAP_ALLOC (NULL);

  propagate = BITMAP_ALLOC (NULL);

  bitmap_copy (queue, decomposable_context);

  do

    {

      bitmap_iterator iter;

      unsigned int i;

      bitmap_clear (propagate);

      EXECUTE_IF_SET_IN_BITMAP (queue, 0, i, iter)

        {

          bitmap b = VEC_index (bitmap, reg_copy_graph, i);

          if (b)

            bitmap_ior_and_compl_into (propagate, b, non_decomposable_context);

        }

      bitmap_and_compl (queue, propagate, decomposable_context);

      bitmap_ior_into (decomposable_context, propagate);

    }

  while (!bitmap_empty_p (queue));

  BITMAP_FREE (queue);

  BITMAP_FREE (propagate);

}

/* A pointer to one of these values is passed to

   find_decomposable_subregs via for_each_rtx.  */

enum classify_move_insn

{

  /* Not a simple move from one location to another.  */

  NOT_SIMPLE_MOVE,

  /* A simple move from one pseudo-register to another.  */

  SIMPLE_PSEUDO_REG_MOVE,

  /* A simple move involving a non-pseudo-register.  */

  SIMPLE_MOVE

};

/* This is called via for_each_rtx.  If we find a SUBREG which we

   could use to decompose a pseudo-register, set a bit in

   DECOMPOSABLE_CONTEXT.  If we find an unadorned register which is

   not a simple pseudo-register copy, DATA will point at the type of

   move, and we set a bit in DECOMPOSABLE_CONTEXT or

   NON_DECOMPOSABLE_CONTEXT as appropriate.  */

static int

find_decomposable_subregs (rtx *px, void *data)

{

  enum classify_move_insn *pcmi = (enum classify_move_insn *) data;

  rtx x = *px;

  if (x == NULL_RTX)

    return 0;

  if (GET_CODE (x) == SUBREG)

    {

      rtx inner = SUBREG_REG (x);

      unsigned int regno, outer_size, inner_size, outer_words, inner_words;

      if (!REG_P (inner))

        return 0;

      regno = REGNO (inner);

      if (HARD_REGISTER_NUM_P (regno))

        return -1;

      outer_size = GET_MODE_SIZE (GET_MODE (x));

      inner_size = GET_MODE_SIZE (GET_MODE (inner));

      outer_words = (outer_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

      inner_words = (inner_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

      /* We only try to decompose single word subregs of multi-word

         registers.  When we find one, we return -1 to avoid iterating

         over the inner register.

         ??? This doesn't allow, e.g., DImode subregs of TImode values

         on 32-bit targets.  We would need to record the way the

         pseudo-register was used, and only decompose if all the uses

         were the same number and size of pieces.  Hopefully this

         doesn't happen much.  */

      if (outer_words == 1 && inner_words > 1)

        {

          bitmap_set_bit (decomposable_context, regno);

          return -1;

        }

      /* If this is a cast from one mode to another, where the modes

         have the same size, and they are not tieable, then mark this

         register as non-decomposable.  If we decompose it we are

         likely to mess up whatever the backend is trying to do.  */

      if (outer_words > 1

          && outer_size == inner_size

          && !MODES_TIEABLE_P (GET_MODE (x), GET_MODE (inner)))

        {

          bitmap_set_bit (non_decomposable_context, regno);

          return -1;

        }

    }

  else if (REG_P (x))

    {

      unsigned int regno;

      /* We will see an outer SUBREG before we see the inner REG, so

         when we see a plain REG here it means a direct reference to

         the register.

         If this is not a simple copy from one location to another,

         then we can not decompose this register.  If this is a simple

         copy from one pseudo-register to another, and the mode is right

         then we mark the register as decomposable.

         Otherwise we don't say anything about this register --

         it could be decomposed, but whether that would be

         profitable depends upon how it is used elsewhere.

         We only set bits in the bitmap for multi-word

         pseudo-registers, since those are the only ones we care about

         and it keeps the size of the bitmaps down.  */

      regno = REGNO (x);

      if (!HARD_REGISTER_NUM_P (regno)

          && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)

        {

          switch (*pcmi)

            {

            case NOT_SIMPLE_MOVE:

              bitmap_set_bit (non_decomposable_context, regno);

              break;

            case SIMPLE_PSEUDO_REG_MOVE:

              if (MODES_TIEABLE_P (GET_MODE (x), word_mode))

                bitmap_set_bit (decomposable_context, regno);

              break;

            case SIMPLE_MOVE:

              break;

            default:

              gcc_unreachable ();

            }

        }

    }

  else if (MEM_P (x))

    {

      enum classify_move_insn cmi_mem = NOT_SIMPLE_MOVE;

      /* Any registers used in a MEM do not participate in a

         SIMPLE_MOVE or SIMPLE_PSEUDO_REG_MOVE.  Do our own recursion

         here, and return -1 to block the parent's recursion.  */

      for_each_rtx (&XEXP (x, 0), find_decomposable_subregs, &cmi_mem);

      return -1;

    }

  return 0;

}

/* Decompose REGNO into word-sized components.  We smash the REG node

   in place.  This ensures that (1) something goes wrong quickly if we

   fail to make some replacement, and (2) the debug information inside

   the symbol table is automatically kept up to date.  */

static void

decompose_register (unsigned int regno)

{

  rtx reg;

  unsigned int words, i;

  rtvec v;

  reg = regno_reg_rtx[regno];

  regno_reg_rtx[regno] = NULL_RTX;

  words = GET_MODE_SIZE (GET_MODE (reg));

  words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

  v = rtvec_alloc (words);

  for (i = 0; i < words; ++i)

    RTVEC_ELT (v, i) = gen_reg_rtx_offset (reg, word_mode, i * UNITS_PER_WORD);

  PUT_CODE (reg, CONCATN);

  XVEC (reg, 0) = v;

  if (dump_file)

    {

      fprintf (dump_file, "; Splitting reg %u ->", regno);

      for (i = 0; i < words; ++i)

        fprintf (dump_file, " %u", REGNO (XVECEXP (reg, 0, i)));

      fputc ('\n', dump_file);

    }

}

/* Get a SUBREG of a CONCATN.  */

static rtx

simplify_subreg_concatn (enum machine_mode outermode, rtx op,

                         unsigned int byte)

{

  unsigned int inner_size;

  enum machine_mode innermode;

  rtx part;

  unsigned int final_offset;

  gcc_assert (GET_CODE (op) == CONCATN);

  gcc_assert (byte % GET_MODE_SIZE (outermode) == 0);

  innermode = GET_MODE (op);

  gcc_assert (byte < GET_MODE_SIZE (innermode));

  gcc_assert (GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (innermode));

  inner_size = GET_MODE_SIZE (innermode) / XVECLEN (op, 0);

  part = XVECEXP (op, 0, byte / inner_size);

  final_offset = byte % inner_size;

  if (final_offset + GET_MODE_SIZE (outermode) > inner_size)

    return NULL_RTX;

  return simplify_gen_subreg (outermode, part, GET_MODE (part), final_offset);

}

/* Wrapper around simplify_gen_subreg which handles CONCATN.  */

static rtx

simplify_gen_subreg_concatn (enum machine_mode outermode, rtx op,

                             enum machine_mode innermode, unsigned int byte)

{

  rtx ret;

  /* We have to handle generating a SUBREG of a SUBREG of a CONCATN.

     If OP is a SUBREG of a CONCATN, then it must be a simple mode

     change with the same size and offset 0, or it must extract a

     part.  We shouldn't see anything else here.  */

  if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == CONCATN)

    {

      rtx op2;

      if ((GET_MODE_SIZE (GET_MODE (op))

           == GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))

          && SUBREG_BYTE (op) == 0)

        return simplify_gen_subreg_concatn (outermode, SUBREG_REG (op),

                                            GET_MODE (SUBREG_REG (op)), byte);

      op2 = simplify_subreg_concatn (GET_MODE (op), SUBREG_REG (op),

                                     SUBREG_BYTE (op));

      if (op2 == NULL_RTX)

        {

          /* We don't handle paradoxical subregs here.  */

          gcc_assert (GET_MODE_SIZE (outermode)

                      <= GET_MODE_SIZE (GET_MODE (op)));

          gcc_assert (GET_MODE_SIZE (GET_MODE (op))

                      <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))));

          op2 = simplify_subreg_concatn (outermode, SUBREG_REG (op),

                                         byte + SUBREG_BYTE (op));

          gcc_assert (op2 != NULL_RTX);

          return op2;

        }

      op = op2;

      gcc_assert (op != NULL_RTX);

      gcc_assert (innermode == GET_MODE (op));

    }

  if (GET_CODE (op) == CONCATN)

    return simplify_subreg_concatn (outermode, op, byte);

  ret = simplify_gen_subreg (outermode, op, innermode, byte);

  /* If we see an insn like (set (reg:DI) (subreg:DI (reg:SI) 0)) then

     resolve_simple_move will ask for the high part of the paradoxical

     subreg, which does not have a value.  Just return a zero.  */

  if (ret == NULL_RTX

      && GET_CODE (op) == SUBREG

      && SUBREG_BYTE (op) == 0

      && (GET_MODE_SIZE (innermode)

          > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op)))))

    return CONST0_RTX (outermode);

  gcc_assert (ret != NULL_RTX);

  return ret;

}

/* Return whether we should resolve X into the registers into which it

   was decomposed.  */

static bool

resolve_reg_p (rtx x)

{

  return GET_CODE (x) == CONCATN;

}

/* Return whether X is a SUBREG of a register which we need to

   resolve.  */

static bool

resolve_subreg_p (rtx x)

{

  if (GET_CODE (x) != SUBREG)

    return false;

  return resolve_reg_p (SUBREG_REG (x));

}

/* This is called via for_each_rtx.  Look for SUBREGs which need to be

   decomposed.  */

static int

resolve_subreg_use (rtx *px, void *data)

{

  rtx insn = (rtx) data;

  rtx x = *px;

  if (x == NULL_RTX)

    return 0;

  if (resolve_subreg_p (x))

    {

      x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),

                                   SUBREG_BYTE (x));

      /* It is possible for a note to contain a reference which we can

         decompose.  In this case, return 1 to the caller to indicate

         that the note must be removed.  */

      if (!x)

        {

          gcc_assert (!insn);

          return 1;

        }

      validate_change (insn, px, x, 1);

      return -1;

    }

  if (resolve_reg_p (x))

    {

      /* Return 1 to the caller to indicate that we found a direct

         reference to a register which is being decomposed.  This can

         happen inside notes, multiword shift or zero-extend

         instructions.  */

      return 1;

    }

  return 0;

}

/* This is called via for_each_rtx.  Look for SUBREGs which can be

   decomposed and decomposed REGs that need copying.  */

static int

adjust_decomposed_uses (rtx *px, void *data ATTRIBUTE_UNUSED)

{

  rtx x = *px;

  if (x == NULL_RTX)

    return 0;

  if (resolve_subreg_p (x))

    {

      x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),

                                   SUBREG_BYTE (x));

      if (x)

        *px = x;

      else

        x = copy_rtx (*px);

    }

  if (resolve_reg_p (x))

    *px = copy_rtx (x);

  return 0;

}

/* Resolve any decomposed registers which appear in register notes on

   INSN.  */

static void

resolve_reg_notes (rtx insn)

{

  rtx *pnote, note;

  note = find_reg_equal_equiv_note (insn);

  if (note)

    {

      int old_count = num_validated_changes ();

      if (for_each_rtx (&XEXP (note, 0), resolve_subreg_use, NULL))

        remove_note (insn, note);

      else

        if (old_count != num_validated_changes ())

          df_notes_rescan (insn);

    }

  pnote = &REG_NOTES (insn);

  while (*pnote != NULL_RTX)

    {

      bool del = false;

      note = *pnote;

      switch (REG_NOTE_KIND (note))

        {

        case REG_DEAD:

        case REG_UNUSED:

          if (resolve_reg_p (XEXP (note, 0)))

            del = true;

          break;

        default:

          break;

        }

      if (del)

        *pnote = XEXP (note, 1);

      else

        pnote = &XEXP (note, 1);

    }

}

/* Return whether X can be decomposed into subwords.  */

static bool

can_decompose_p (rtx x)

{

  if (REG_P (x))

    {

      unsigned int regno = REGNO (x);

      if (HARD_REGISTER_NUM_P (regno))

        return (validate_subreg (word_mode, GET_MODE (x), x, UNITS_PER_WORD)

                && HARD_REGNO_MODE_OK (regno, word_mode));

      else

        return !bitmap_bit_p (non_decomposable_context, regno);

    }

  return true;

}

/* Decompose the registers used in a simple move SET within INSN.  If

   we don't change anything, return INSN, otherwise return the start

   of the sequence of moves.  */

static rtx

resolve_simple_move (rtx set, rtx insn)

{

  rtx src, dest, real_dest, insns;

  enum machine_mode orig_mode, dest_mode;

  unsigned int words;

  bool pushing;

  src = SET_SRC (set);

  dest = SET_DEST (set);

  orig_mode = GET_MODE (dest);

  words = (GET_MODE_SIZE (orig_mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

  if (words <= 1)

    return insn;

  start_sequence ();

  /* We have to handle copying from a SUBREG of a decomposed reg where

     the SUBREG is larger than word size.  Rather than assume that we

     can take a word_mode SUBREG of the destination, we copy to a new

     register and then copy that to the destination.  */

  real_dest = NULL_RTX;

  if (GET_CODE (src) == SUBREG

      && resolve_reg_p (SUBREG_REG (src))

      && (SUBREG_BYTE (src) != 0

          || (GET_MODE_SIZE (orig_mode)

              != GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))))

    {

      real_dest = dest;

      dest = gen_reg_rtx (orig_mode);

      if (REG_P (real_dest))

        REG_ATTRS (dest) = REG_ATTRS (real_dest);

    }

  /* Similarly if we are copying to a SUBREG of a decomposed reg where

     the SUBREG is larger than word size.  */

  if (GET_CODE (dest) == SUBREG

      && resolve_reg_p (SUBREG_REG (dest))

      && (SUBREG_BYTE (dest) != 0

          || (GET_MODE_SIZE (orig_mode)

              != GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))))))

    {

      rtx reg, minsn, smove;

      reg = gen_reg_rtx (orig_mode);

      minsn = emit_move_insn (reg, src);

      smove = single_set (minsn);

      gcc_assert (smove != NULL_RTX);

      resolve_simple_move (smove, minsn);

      src = reg;

    }

  /* If we didn't have any big SUBREGS of decomposed registers, and

     neither side of the move is a register we are decomposing, then

     we don't have to do anything here.  */

  if (src == SET_SRC (set)

      && dest == SET_DEST (set)

      && !resolve_reg_p (src)

      && !resolve_subreg_p (src)

      && !resolve_reg_p (dest)

      && !resolve_subreg_p (dest))

    {

      end_sequence ();

      return insn;

    }

  /* It's possible for the code to use a subreg of a decomposed

     register while forming an address.  We need to handle that before

     passing the address to emit_move_insn.  We pass NULL_RTX as the

     insn parameter to resolve_subreg_use because we can not validate

     the insn yet.  */

  if (MEM_P (src) || MEM_P (dest))

    {

      int acg;

      if (MEM_P (src))