[thirdparty/gcc.git] / gcc / df.c

/* Dataflow support routines.
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
   Free Software Foundation, Inc.
   Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz,
                                    mhayes@redhat.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 2, 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 COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.


OVERVIEW:

This file provides some dataflow routines for computing reaching defs,
upward exposed uses, live variables, def-use chains, and use-def
chains.  The global dataflow is performed using simple iterative
methods with a worklist and could be sped up by ordering the blocks
with a depth first search order.

A `struct ref' data structure (ref) is allocated for every register
reference (def or use) and this records the insn and bb the ref is
found within.  The refs are linked together in chains of uses and defs
for each insn and for each register.  Each ref also has a chain field
that links all the use refs for a def or all the def refs for a use.
This is used to create use-def or def-use chains.


USAGE:

Here's an example of using the dataflow routines.

      struct df *df;

      df = df_init ();

      df_analyze (df, 0, DF_ALL);

      df_dump (df, DF_ALL, stderr);

      df_finish (df);


df_init simply creates a poor man's object (df) that needs to be
passed to all the dataflow routines.  df_finish destroys this
object and frees up any allocated memory.   DF_ALL says to analyze
everything.

df_analyze performs the following:

1. Records defs and uses by scanning the insns in each basic block
   or by scanning the insns queued by df_insn_modify.
2. Links defs and uses into insn-def and insn-use chains.
3. Links defs and uses into reg-def and reg-use chains.
4. Assigns LUIDs to each insn (for modified blocks).
5. Calculates local reaching definitions.
6. Calculates global reaching definitions.
7. Creates use-def chains.
8. Calculates local reaching uses (upwards exposed uses).
9. Calculates global reaching uses.
10. Creates def-use chains.
11. Calculates local live registers.
12. Calculates global live registers.
13. Calculates register lifetimes and determines local registers.


PHILOSOPHY:

Note that the dataflow information is not updated for every newly
deleted or created insn.  If the dataflow information requires
updating then all the changed, new, or deleted insns needs to be
marked with df_insn_modify (or df_insns_modify) either directly or
indirectly (say through calling df_insn_delete).  df_insn_modify
marks all the modified insns to get processed the next time df_analyze
 is called.

Beware that tinkering with insns may invalidate the dataflow information.
The philosophy behind these routines is that once the dataflow
information has been gathered, the user should store what they require
before they tinker with any insn.  Once a reg is replaced, for example,
then the reg-def/reg-use chains will point to the wrong place.  Once a
whole lot of changes have been made, df_analyze can be called again
to update the dataflow information.  Currently, this is not very smart
with regard to propagating changes to the dataflow so it should not
be called very often.


DATA STRUCTURES:

The basic object is a REF (reference) and this may either be a DEF
(definition) or a USE of a register.

These are linked into a variety of lists; namely reg-def, reg-use,
  insn-def, insn-use, def-use, and use-def lists.  For example,
the reg-def lists contain all the refs that define a given register
while the insn-use lists contain all the refs used by an insn.

Note that the reg-def and reg-use chains are generally short (except for
the hard registers) and thus it is much faster to search these chains
rather than searching the def or use bitmaps.

If the insns are in SSA form then the reg-def and use-def lists
should only contain the single defining ref.


TODO:

1) Incremental dataflow analysis.

Note that if a loop invariant insn is hoisted (or sunk), we do not
need to change the def-use or use-def chains.  All we have to do is to
change the bb field for all the associated defs and uses and to
renumber the LUIDs for the original and new basic blocks of the insn.

When shadowing loop mems we create new uses and defs for new pseudos
so we do not affect the existing dataflow information.

My current strategy is to queue up all modified, created, or deleted
insns so when df_analyze is called we can easily determine all the new
or deleted refs.  Currently the global dataflow information is
recomputed from scratch but this could be propagated more efficiently.

2) Reduced memory requirements.

We could operate a pool of ref structures.  When a ref is deleted it
gets returned to the pool (say by linking on to a chain of free refs).
This will require a pair of bitmaps for defs and uses so that we can
tell which ones have been changed.  Alternatively, we could
periodically squeeze the def and use tables and associated bitmaps and
renumber the def and use ids.

3) Ordering of reg-def and reg-use lists.

Should the first entry in the def list be the first def (within a BB)?
Similarly, should the first entry in the use list be the last use
(within a BB)?

4) Working with a sub-CFG.

Often the whole CFG does not need to be analyzed, for example,
when optimizing a loop, only certain registers are of interest.
Perhaps there should be a bitmap argument to df_analyze to specify
which registers should be analyzed?


NOTES:

Embedded addressing side-effects, such as POST_INC or PRE_INC, generate
both a use and a def.  These are both marked read/write to show that they
are dependent. For example, (set (reg 40) (mem (post_inc (reg 42))))
will generate a use of reg 42 followed by a def of reg 42 (both marked
read/write).  Similarly, (set (reg 40) (mem (pre_dec (reg 41))))
generates a use of reg 41 then a def of reg 41 (both marked read/write),
even though reg 41 is decremented before it is used for the memory
address in this second example.

A set to a REG inside a ZERO_EXTRACT, or a set to a non-paradoxical SUBREG
for which the number of word_mode units covered by the outer mode is
smaller than that covered by the inner mode, invokes a read-modify-write.
operation.  We generate both a use and a def and again mark them
read/write.
Paradoxical subreg writes don't leave a trace of the old content, so they
are write-only operations.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "tm_p.h"
#include "insn-config.h"
#include "recog.h"
#include "function.h"
#include "regs.h"
#include "alloc-pool.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "sbitmap.h"
#include "bitmap.h"
#include "df.h"

#define FOR_EACH_BB_IN_BITMAP(BITMAP, MIN, BB, CODE)    \
  do                                                    \
    {                                                   \
      unsigned int node_;                               \
      bitmap_iterator bi;                               \
      EXECUTE_IF_SET_IN_BITMAP (BITMAP, MIN, node_, bi) \
        {                                               \
          (BB) = BASIC_BLOCK (node_);                   \
          CODE;                                         \
        }                                               \
    }                                                   \
  while (0)

static alloc_pool df_ref_pool;
static alloc_pool df_link_pool;
static struct df *ddf;

static void df_reg_table_realloc (struct df *, int);
static void df_insn_table_realloc (struct df *, unsigned int);
static void df_bb_table_realloc (struct df *, unsigned int);
static void df_bitmaps_alloc (struct df *, bitmap, int);
static void df_bitmaps_free (struct df *, int);
static void df_free (struct df *);
static void df_alloc (struct df *, int);

static rtx df_reg_use_gen (unsigned int);

static inline struct df_link *df_link_create (struct ref *, struct df_link *);
static struct df_link *df_ref_unlink (struct df_link **, struct ref *);
static void df_def_unlink (struct df *, struct ref *);
static void df_use_unlink (struct df *, struct ref *);
static void df_insn_refs_unlink (struct df *, basic_block, rtx);
#if 0
static void df_bb_refs_unlink (struct df *, basic_block);
static void df_refs_unlink (struct df *, bitmap);
#endif

static struct ref *df_ref_create (struct df *, rtx, rtx *, rtx,
                                  enum df_ref_type, enum df_ref_flags);
static void df_ref_record_1 (struct df *, rtx, rtx *, rtx, enum df_ref_type,
                             enum df_ref_flags);
static void df_ref_record (struct df *, rtx, rtx *, rtx, enum df_ref_type,
                           enum df_ref_flags);
static void df_def_record_1 (struct df *, rtx, basic_block, rtx);
static void df_defs_record (struct df *, rtx, basic_block, rtx);
static void df_uses_record (struct df *, rtx *, enum df_ref_type,
                            basic_block, rtx, enum df_ref_flags);
static void df_insn_refs_record (struct df *, basic_block, rtx);
static void df_bb_refs_record (struct df *, basic_block);
static void df_refs_record (struct df *, bitmap);

static void df_bb_reg_def_chain_create (struct df *, basic_block);
static void df_reg_def_chain_create (struct df *, bitmap, bool);
static void df_bb_reg_use_chain_create (struct df *, basic_block);
static void df_reg_use_chain_create (struct df *, bitmap, bool);
static void df_bb_du_chain_create (struct df *, basic_block, bitmap);
static void df_du_chain_create (struct df *, bitmap);
static void df_bb_ud_chain_create (struct df *, basic_block);
static void df_ud_chain_create (struct df *, bitmap);
static void df_bb_rd_local_compute (struct df *, basic_block, bitmap);
static void df_rd_local_compute (struct df *, bitmap);
static void df_bb_ru_local_compute (struct df *, basic_block);
static void df_ru_local_compute (struct df *, bitmap);
static void df_bb_lr_local_compute (struct df *, basic_block);
static void df_lr_local_compute (struct df *, bitmap);
static void df_bb_reg_info_compute (struct df *, basic_block, bitmap);
static void df_reg_info_compute (struct df *, bitmap);

static int df_bb_luids_set (struct df *df, basic_block);
static int df_luids_set (struct df *df, bitmap);

static int df_modified_p (struct df *, bitmap);
static int df_refs_queue (struct df *);
static int df_refs_process (struct df *);
static int df_bb_refs_update (struct df *, basic_block);
static int df_refs_update (struct df *, bitmap);
static void df_analyze_1 (struct df *, bitmap, int, int);

static void df_insns_modify (struct df *, basic_block, rtx, rtx);
static int df_rtx_mem_replace (rtx *, void *);
static int df_rtx_reg_replace (rtx *, void *);
void df_refs_reg_replace (struct df *, bitmap, struct df_link *, rtx, rtx);

static int df_def_dominates_all_uses_p (struct df *, struct ref *def);
static int df_def_dominates_uses_p (struct df *, struct ref *def, bitmap);
static struct ref *df_bb_insn_regno_last_use_find (struct df *, basic_block,
                                                   rtx, unsigned int);
static struct ref *df_bb_insn_regno_first_def_find (struct df *, basic_block,
                                                    rtx, unsigned int);

static void df_chain_dump (struct df_link *, FILE *file);
static void df_chain_dump_regno (struct df_link *, FILE *file);
static void df_regno_debug (struct df *, unsigned int, FILE *);
static void df_ref_debug (struct df *, struct ref *, FILE *);
static void df_rd_transfer_function (int, int *, void *, void *, void *,
                                     void *, void *);
static void df_ru_transfer_function (int, int *, void *, void *, void *,
                                     void *, void *);
static void df_lr_transfer_function (int, int *, void *, void *, void *,
                                     void *, void *);
static void hybrid_search (basic_block, struct dataflow *,
                           sbitmap, sbitmap, sbitmap);

\f
/* Local memory allocation/deallocation routines.  */


/* Increase the insn info table to have space for at least SIZE + 1
   elements.  */
static void
df_insn_table_realloc (struct df *df, unsigned int size)
{
  size++;
  if (size <= df->insn_size)
    return;

  /* Make the table a little larger than requested, so we do not need
     to enlarge it so often.  */
  size += df->insn_size / 4;

  df->insns = xrealloc (df->insns, size * sizeof (struct insn_info));

  memset (df->insns + df->insn_size, 0,
          (size - df->insn_size) * sizeof (struct insn_info));

  df->insn_size = size;

  if (! df->insns_modified)
    {
      df->insns_modified = BITMAP_XMALLOC ();
      bitmap_zero (df->insns_modified);
    }
}

/* Increase the bb info table to have space for at least SIZE + 1
   elements.  */

static void
df_bb_table_realloc (struct df *df, unsigned int size)
{
  size++;
  if (size <= df->n_bbs)
    return;

  /* Make the table a little larger than requested, so we do not need
     to enlarge it so often.  */
  size += df->n_bbs / 4;

  df->bbs = xrealloc (df->bbs, size * sizeof (struct bb_info));

  memset (df->bbs + df->n_bbs, 0, (size - df->n_bbs) * sizeof (struct bb_info));

  df->n_bbs = size;
}

/* Increase the reg info table by SIZE more elements.  */
static void
df_reg_table_realloc (struct df *df, int size)
{
  /* Make table 25 percent larger by default.  */
  if (! size)
    size = df->reg_size / 4;

  size += df->reg_size;
  if (size < max_reg_num ())
    size = max_reg_num ();

  df->regs = xrealloc (df->regs, size * sizeof (struct reg_info));
  df->reg_def_last = xrealloc (df->reg_def_last,
                               size * sizeof (struct ref *));

  /* Zero the new entries.  */
  memset (df->regs + df->reg_size, 0,
          (size - df->reg_size) * sizeof (struct reg_info));

  df->reg_size = size;
}


/* Allocate bitmaps for each basic block.  */

static void
df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
{
  basic_block bb;

  df->n_defs = df->def_id;
  df->n_uses = df->use_id;

  if (!blocks)
    blocks = df->all_blocks;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      struct bb_info *bb_info = DF_BB_INFO (df, bb);

      if (flags & DF_RD)
        {
          if (!bb_info->rd_in)
            {
              /* Allocate bitmaps for reaching definitions.  */
              bb_info->rd_kill = BITMAP_XMALLOC ();
              bb_info->rd_gen = BITMAP_XMALLOC ();
              bb_info->rd_in = BITMAP_XMALLOC ();
              bb_info->rd_out = BITMAP_XMALLOC ();
            }
          else
            {
              bitmap_clear (bb_info->rd_kill);
              bitmap_clear (bb_info->rd_gen);
              bitmap_clear (bb_info->rd_in);
              bitmap_clear (bb_info->rd_out);
            }
        }

      if (flags & DF_RU)
        {
          if (!bb_info->ru_in)
            {
              /* Allocate bitmaps for upward exposed uses.  */
              bb_info->ru_kill = BITMAP_XMALLOC ();
              bb_info->ru_gen = BITMAP_XMALLOC ();
              bb_info->ru_in = BITMAP_XMALLOC ();
              bb_info->ru_out = BITMAP_XMALLOC ();
            }
          else
            {
              bitmap_clear (bb_info->ru_kill);
              bitmap_clear (bb_info->ru_gen);
              bitmap_clear (bb_info->ru_in);
              bitmap_clear (bb_info->ru_out);
            }
        }

      if (flags & DF_LR)
        {
          if (!bb_info->lr_in)
            {
              /* Allocate bitmaps for live variables.  */
              bb_info->lr_def = BITMAP_XMALLOC ();
              bb_info->lr_use = BITMAP_XMALLOC ();
              bb_info->lr_in = BITMAP_XMALLOC ();
              bb_info->lr_out = BITMAP_XMALLOC ();
            }
          else
            {
              bitmap_clear (bb_info->lr_def);
              bitmap_clear (bb_info->lr_use);
              bitmap_clear (bb_info->lr_in);
              bitmap_clear (bb_info->lr_out);
            }
        }
    });
}


/* Free bitmaps for each basic block.  */
static void
df_bitmaps_free (struct df *df, int flags)
{
  basic_block bb;

  FOR_EACH_BB (bb)
    {
      struct bb_info *bb_info = DF_BB_INFO (df, bb);

      if (!bb_info)
        continue;

      if ((flags & DF_RD) && bb_info->rd_in)
        {
          /* Free bitmaps for reaching definitions.  */
          BITMAP_XFREE (bb_info->rd_kill);
          bb_info->rd_kill = NULL;
          BITMAP_XFREE (bb_info->rd_gen);
          bb_info->rd_gen = NULL;
          BITMAP_XFREE (bb_info->rd_in);
          bb_info->rd_in = NULL;
          BITMAP_XFREE (bb_info->rd_out);
          bb_info->rd_out = NULL;
        }

      if ((flags & DF_RU) && bb_info->ru_in)
        {
          /* Free bitmaps for upward exposed uses.  */
          BITMAP_XFREE (bb_info->ru_kill);
          bb_info->ru_kill = NULL;
          BITMAP_XFREE (bb_info->ru_gen);
          bb_info->ru_gen = NULL;
          BITMAP_XFREE (bb_info->ru_in);
          bb_info->ru_in = NULL;
          BITMAP_XFREE (bb_info->ru_out);
          bb_info->ru_out = NULL;
        }

      if ((flags & DF_LR) && bb_info->lr_in)
        {
          /* Free bitmaps for live variables.  */
          BITMAP_XFREE (bb_info->lr_def);
          bb_info->lr_def = NULL;
          BITMAP_XFREE (bb_info->lr_use);
          bb_info->lr_use = NULL;
          BITMAP_XFREE (bb_info->lr_in);
          bb_info->lr_in = NULL;
          BITMAP_XFREE (bb_info->lr_out);
          bb_info->lr_out = NULL;
        }
    }
  df->flags &= ~(flags & (DF_RD | DF_RU | DF_LR));
}


/* Allocate and initialize dataflow memory.  */
static void
df_alloc (struct df *df, int n_regs)
{
  int n_insns;
  basic_block bb;

  df_link_pool = create_alloc_pool ("df_link pool", sizeof (struct df_link),
                                    100);
  df_ref_pool  = create_alloc_pool ("df_ref pool", sizeof (struct ref), 100);

  /* Perhaps we should use LUIDs to save memory for the insn_refs
     table.  This is only a small saving; a few pointers.  */
  n_insns = get_max_uid () + 1;

  df->def_id = 0;
  df->n_defs = 0;
  /* Approximate number of defs by number of insns.  */
  df->def_size = n_insns;
  df->defs = xmalloc (df->def_size * sizeof (*df->defs));

  df->use_id = 0;
  df->n_uses = 0;
  /* Approximate number of uses by twice number of insns.  */
  df->use_size = n_insns * 2;
  df->uses = xmalloc (df->use_size * sizeof (*df->uses));

  df->n_regs = n_regs;
  df->n_bbs = last_basic_block;

  /* Allocate temporary working array used during local dataflow analysis.  */
  df_insn_table_realloc (df, n_insns);

  df_reg_table_realloc (df, df->n_regs);

  df->bbs_modified = BITMAP_XMALLOC ();
  bitmap_zero (df->bbs_modified);

  df->flags = 0;

  df->bbs = xcalloc (last_basic_block, sizeof (struct bb_info));

  df->all_blocks = BITMAP_XMALLOC ();
  FOR_EACH_BB (bb)
    bitmap_set_bit (df->all_blocks, bb->index);
}


/* Free all the dataflow info.  */
static void
df_free (struct df *df)
{
  df_bitmaps_free (df, DF_ALL);

  if (df->bbs)
    free (df->bbs);
  df->bbs = 0;

  if (df->insns)
    free (df->insns);
  df->insns = 0;
  df->insn_size = 0;

  if (df->defs)
    free (df->defs);
  df->defs = 0;
  df->def_size = 0;
  df->def_id = 0;

  if (df->uses)
    free (df->uses);
  df->uses = 0;
  df->use_size = 0;
  df->use_id = 0;

  if (df->regs)
    free (df->regs);
  df->regs = 0;
  df->reg_size = 0;

  BITMAP_XFREE (df->bbs_modified);
  df->bbs_modified = 0;

  BITMAP_XFREE (df->insns_modified);
  df->insns_modified = 0;

  BITMAP_XFREE (df->all_blocks);
  df->all_blocks = 0;

  free_alloc_pool (df_ref_pool);
  free_alloc_pool (df_link_pool);
}
\f
/* Local miscellaneous routines.  */

/* Return a USE for register REGNO.  */
static rtx df_reg_use_gen (unsigned int regno)
{
  rtx reg;
  rtx use;

  reg = regno_reg_rtx[regno];

  use = gen_rtx_USE (GET_MODE (reg), reg);
  return use;
}
\f
/* Local chain manipulation routines.  */

/* Create a link in a def-use or use-def chain.  */
static inline struct df_link *
df_link_create (struct ref *ref, struct df_link *next)
{
  struct df_link *link;

  link = pool_alloc (df_link_pool);
  link->next = next;
  link->ref = ref;
  return link;
}

/* Releases members of the CHAIN.  */

static void
free_reg_ref_chain (struct df_link **chain)
{
  struct df_link *act, *next;

  for (act = *chain; act; act = next)
    {
      next = act->next;
      pool_free (df_link_pool, act);
    }

  *chain = NULL;
}

/* Add REF to chain head pointed to by PHEAD.  */
static struct df_link *
df_ref_unlink (struct df_link **phead, struct ref *ref)
{
  struct df_link *link = *phead;

  if (link)
    {
      if (! link->next)
        {
          /* Only a single ref.  It must be the one we want.
             If not, the def-use and use-def chains are likely to
             be inconsistent.  */
          gcc_assert (link->ref == ref);
          
          /* Now have an empty chain.  */
          *phead = NULL;
        }
      else
        {
          /* Multiple refs.  One of them must be us.  */
          if (link->ref == ref)
            *phead = link->next;
          else
            {
              /* Follow chain.  */
              for (; link->next; link = link->next)
                {
                  if (link->next->ref == ref)
                    {
                      /* Unlink from list.  */
                      link->next = link->next->next;
                      return link->next;
                    }
                }
            }
        }
    }
  return link;
}


/* Unlink REF from all def-use/use-def chains, etc.  */
int
df_ref_remove (struct df *df, struct ref *ref)
{
  if (DF_REF_REG_DEF_P (ref))
    {
      df_def_unlink (df, ref);
      df_ref_unlink (&df->insns[DF_REF_INSN_UID (ref)].defs, ref);
    }
  else
    {
      df_use_unlink (df, ref);
      df_ref_unlink (&df->insns[DF_REF_INSN_UID (ref)].uses, ref);
    }
  return 1;
}


/* Unlink DEF from use-def and reg-def chains.  */
static void
df_def_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
  struct df_link *du_link;
  unsigned int dregno = DF_REF_REGNO (def);

  /* Follow def-use chain to find all the uses of this def.  */
  for (du_link = DF_REF_CHAIN (def); du_link; du_link = du_link->next)
    {
      struct ref *use = du_link->ref;

      /* Unlink this def from the use-def chain.  */
      df_ref_unlink (&DF_REF_CHAIN (use), def);
    }
  DF_REF_CHAIN (def) = 0;

  /* Unlink def from reg-def chain.  */
  df_ref_unlink (&df->regs[dregno].defs, def);

  df->defs[DF_REF_ID (def)] = 0;
}


/* Unlink use from def-use and reg-use chains.  */
static void
df_use_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *use)
{
  struct df_link *ud_link;
  unsigned int uregno = DF_REF_REGNO (use);

  /* Follow use-def chain to find all the defs of this use.  */
  for (ud_link = DF_REF_CHAIN (use); ud_link; ud_link = ud_link->next)
    {
      struct ref *def = ud_link->ref;

      /* Unlink this use from the def-use chain.  */
      df_ref_unlink (&DF_REF_CHAIN (def), use);
    }
  DF_REF_CHAIN (use) = 0;

  /* Unlink use from reg-use chain.  */
  df_ref_unlink (&df->regs[uregno].uses, use);

  df->uses[DF_REF_ID (use)] = 0;
}
\f
/* Local routines for recording refs.  */


/* Create a new ref of type DF_REF_TYPE for register REG at address
   LOC within INSN of BB.  */
static struct ref *
df_ref_create (struct df *df, rtx reg, rtx *loc, rtx insn,
               enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
  struct ref *this_ref;

  this_ref = pool_alloc (df_ref_pool);
  DF_REF_REG (this_ref) = reg;
  DF_REF_LOC (this_ref) = loc;
  DF_REF_INSN (this_ref) = insn;
  DF_REF_CHAIN (this_ref) = 0;
  DF_REF_TYPE (this_ref) = ref_type;
  DF_REF_FLAGS (this_ref) = ref_flags;
  DF_REF_DATA (this_ref) = NULL;

  if (ref_type == DF_REF_REG_DEF)
    {
      if (df->def_id >= df->def_size)
        {
          /* Make table 25 percent larger.  */
          df->def_size += (df->def_size / 4);
          df->defs = xrealloc (df->defs,
                               df->def_size * sizeof (*df->defs));
        }
      DF_REF_ID (this_ref) = df->def_id;
      df->defs[df->def_id++] = this_ref;
    }
  else
    {
      if (df->use_id >= df->use_size)
        {
          /* Make table 25 percent larger.  */
          df->use_size += (df->use_size / 4);
          df->uses = xrealloc (df->uses,
                               df->use_size * sizeof (*df->uses));
        }
      DF_REF_ID (this_ref) = df->use_id;
      df->uses[df->use_id++] = this_ref;
    }
  return this_ref;
}


/* Create a new reference of type DF_REF_TYPE for a single register REG,
   used inside the LOC rtx of INSN.  */
static void
df_ref_record_1 (struct df *df, rtx reg, rtx *loc, rtx insn,
                 enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
  df_ref_create (df, reg, loc, insn, ref_type, ref_flags);
}


/* Create new references of type DF_REF_TYPE for each part of register REG
   at address LOC within INSN of BB.  */
static void
df_ref_record (struct df *df, rtx reg, rtx *loc, rtx insn,
               enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
  unsigned int regno;

  gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);

  /* For the reg allocator we are interested in some SUBREG rtx's, but not
     all.  Notably only those representing a word extraction from a multi-word
     reg.  As written in the docu those should have the form
     (subreg:SI (reg:M A) N), with size(SImode) > size(Mmode).
     XXX Is that true?  We could also use the global word_mode variable.  */
  if (GET_CODE (reg) == SUBREG
      && (GET_MODE_SIZE (GET_MODE (reg)) < GET_MODE_SIZE (word_mode)
          || GET_MODE_SIZE (GET_MODE (reg))
               >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (reg)))))
    {
      loc = &SUBREG_REG (reg);
      reg = *loc;
      ref_flags |= DF_REF_STRIPPED;
    }

  regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
  if (regno < FIRST_PSEUDO_REGISTER)
    {
      int i;
      int endregno;

      if (! (df->flags & DF_HARD_REGS))
        return;

      /* GET_MODE (reg) is correct here.  We do not want to go into a SUBREG
         for the mode, because we only want to add references to regs, which
         are really referenced.  E.g., a (subreg:SI (reg:DI 0) 0) does _not_
         reference the whole reg 0 in DI mode (which would also include
         reg 1, at least, if 0 and 1 are SImode registers).  */
      endregno = hard_regno_nregs[regno][GET_MODE (reg)];
      if (GET_CODE (reg) == SUBREG)
        regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
                                      SUBREG_BYTE (reg), GET_MODE (reg));
      endregno += regno;

      for (i = regno; i < endregno; i++)
        df_ref_record_1 (df, regno_reg_rtx[i],
                         loc, insn, ref_type, ref_flags);
    }
  else
    {
      df_ref_record_1 (df, reg, loc, insn, ref_type, ref_flags);
    }
}


/* A set to a non-paradoxical SUBREG for which the number of word_mode units
   covered by the outer mode is smaller than that covered by the inner mode,
   is a read-modify-write operation.
   This function returns true iff the SUBREG X is such a SUBREG.  */
bool
read_modify_subreg_p (rtx x)
{
  unsigned int isize, osize;
  if (GET_CODE (x) != SUBREG)
    return false;
  isize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
  osize = GET_MODE_SIZE (GET_MODE (x));
  return (isize > osize && isize > UNITS_PER_WORD);
}


/* Process all the registers defined in the rtx, X.  */
static void
df_def_record_1 (struct df *df, rtx x, basic_block bb, rtx insn)
{
  rtx *loc;
  rtx dst;
  enum df_ref_flags flags = 0;

 /* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
     construct.  */
  if (GET_CODE (x) == EXPR_LIST || GET_CODE (x) == CLOBBER)
    loc = &XEXP (x, 0);
  else
    loc = &SET_DEST (x);
  dst = *loc;

  /* Some targets place small structures in registers for
     return values of functions.  */
  if (GET_CODE (dst) == PARALLEL && GET_MODE (dst) == BLKmode)
    {
      int i;

      for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
        {
          rtx temp = XVECEXP (dst, 0, i);
          if (GET_CODE (temp) == EXPR_LIST || GET_CODE (temp) == CLOBBER
              || GET_CODE (temp) == SET)
            df_def_record_1 (df, temp, bb, insn);
        }
      return;
    }

  /* Maybe, we should flag the use of STRICT_LOW_PART somehow.  It might
     be handy for the reg allocator.  */
  while (GET_CODE (dst) == STRICT_LOW_PART
         || GET_CODE (dst) == ZERO_EXTRACT
         || ((df->flags & DF_FOR_REGALLOC) == 0
             && read_modify_subreg_p (dst)))
    {
      /* Strict low part always contains SUBREG, but we do not want to make
         it appear outside, as whole register is always considered.  */
      if (GET_CODE (dst) == STRICT_LOW_PART)
        {
          loc = &XEXP (dst, 0);
          dst = *loc;
        }
      loc = &XEXP (dst, 0);
      dst = *loc;
      flags |= DF_REF_READ_WRITE;
    }

  if (REG_P (dst)
      || (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst))))
    df_ref_record (df, dst, loc, insn, DF_REF_REG_DEF, flags);
}


/* Process all the registers defined in the pattern rtx, X.  */
static void
df_defs_record (struct df *df, rtx x, basic_block bb, rtx insn)
{
  RTX_CODE code = GET_CODE (x);

  if (code == SET || code == CLOBBER)
    {
      /* Mark the single def within the pattern.  */
      df_def_record_1 (df, x, bb, insn);
    }
  else if (code == PARALLEL)
    {
      int i;

      /* Mark the multiple defs within the pattern.  */
      for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
        {
          code = GET_CODE (XVECEXP (x, 0, i));
          if (code == SET || code == CLOBBER)
            df_def_record_1 (df, XVECEXP (x, 0, i), bb, insn);
        }
    }
}


/* Process all the registers used in the rtx at address LOC.  */
static void
df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type,
                basic_block bb, rtx insn, enum df_ref_flags flags)
{
  RTX_CODE code;
  rtx x;
 retry:
  x = *loc;
  if (!x)
    return;
  code = GET_CODE (x);
  switch (code)
    {
    case LABEL_REF:
    case SYMBOL_REF:
    case CONST_INT:
    case CONST:
    case CONST_DOUBLE:
    case CONST_VECTOR:
    case PC:
    case CC0:
    case ADDR_VEC:
    case ADDR_DIFF_VEC:
      return;

    case CLOBBER:
      /* If we are clobbering a MEM, mark any registers inside the address
         as being used.  */
      if (MEM_P (XEXP (x, 0)))
        df_uses_record (df, &XEXP (XEXP (x, 0), 0),
                        DF_REF_REG_MEM_STORE, bb, insn, flags);

      /* If we're clobbering a REG then we have a def so ignore.  */
      return;

    case MEM:
      df_uses_record (df, &XEXP (x, 0), DF_REF_REG_MEM_LOAD, bb, insn, 0);
      return;

    case SUBREG:
      /* While we're here, optimize this case.  */

      /* In case the SUBREG is not of a REG, do not optimize.  */
      if (!REG_P (SUBREG_REG (x)))
        {
          loc = &SUBREG_REG (x);
          df_uses_record (df, loc, ref_type, bb, insn, flags);
          return;
        }
      /* ... Fall through ...  */

    case REG:
      df_ref_record (df, x, loc, insn, ref_type, flags);
      return;

    case SET:
      {
        rtx dst = SET_DEST (x);

        df_uses_record (df, &SET_SRC (x), DF_REF_REG_USE, bb, insn, 0);

        switch (GET_CODE (dst))
          {
            case SUBREG:
              if ((df->flags & DF_FOR_REGALLOC) == 0
                  && read_modify_subreg_p (dst))
                {
                  df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
                                  insn, DF_REF_READ_WRITE);
                  break;
                }
              /* Fall through.  */
            case REG:
            case PARALLEL:
            case PC:
            case CC0:
                break;
            case MEM:
              df_uses_record (df, &XEXP (dst, 0),
                              DF_REF_REG_MEM_STORE,
                              bb, insn, 0);
              break;
            case STRICT_LOW_PART:
              /* A strict_low_part uses the whole REG and not just the
                 SUBREG.  */
              dst = XEXP (dst, 0);
              gcc_assert (GET_CODE (dst) == SUBREG);
              df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
                             insn, DF_REF_READ_WRITE);
              break;
            case ZERO_EXTRACT:
            case SIGN_EXTRACT:
              df_uses_record (df, &XEXP (dst, 0), DF_REF_REG_USE, bb, insn,
                              DF_REF_READ_WRITE);
              df_uses_record (df, &XEXP (dst, 1), DF_REF_REG_USE, bb, insn, 0);
              df_uses_record (df, &XEXP (dst, 2), DF_REF_REG_USE, bb, insn, 0);
              dst = XEXP (dst, 0);
              break;
            default:
              gcc_unreachable ();
          }
        return;
      }

    case RETURN:
      break;

    case ASM_OPERANDS:
    case UNSPEC_VOLATILE:
    case TRAP_IF:
    case ASM_INPUT:
      {
        /* Traditional and volatile asm instructions must be considered to use
           and clobber all hard registers, all pseudo-registers and all of
           memory.  So must TRAP_IF and UNSPEC_VOLATILE operations.

           Consider for instance a volatile asm that changes the fpu rounding
           mode.  An insn should not be moved across this even if it only uses
           pseudo-regs because it might give an incorrectly rounded result.

           For now, just mark any regs we can find in ASM_OPERANDS as
           used.  */

        /* For all ASM_OPERANDS, we must traverse the vector of input operands.
           We can not just fall through here since then we would be confused
           by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
           traditional asms unlike their normal usage.  */
        if (code == ASM_OPERANDS)
          {
            int j;

            for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
              df_uses_record (df, &ASM_OPERANDS_INPUT (x, j),
                              DF_REF_REG_USE, bb, insn, 0);
            return;
          }
        break;
      }

    case PRE_DEC:
    case POST_DEC:
    case PRE_INC:
    case POST_INC:
    case PRE_MODIFY:
    case POST_MODIFY:
      /* Catch the def of the register being modified.  */
      df_ref_record (df, XEXP (x, 0), &XEXP (x, 0), insn, DF_REF_REG_DEF, DF_REF_READ_WRITE);

      /* ... Fall through to handle uses ...  */

    default:
      break;
    }

  /* Recursively scan the operands of this expression.  */
  {
    const char *fmt = GET_RTX_FORMAT (code);
    int i;

    for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
      {
        if (fmt[i] == 'e')
          {
            /* Tail recursive case: save a function call level.  */
            if (i == 0)
              {
                loc = &XEXP (x, 0);
                goto retry;
              }
            df_uses_record (df, &XEXP (x, i), ref_type, bb, insn, flags);
          }
        else if (fmt[i] == 'E')
          {
            int j;
            for (j = 0; j < XVECLEN (x, i); j++)
              df_uses_record (df, &XVECEXP (x, i, j), ref_type,
                              bb, insn, flags);
          }
      }
  }
}


/* Record all the df within INSN of basic block BB.  */
static void
df_insn_refs_record (struct df *df, basic_block bb, rtx insn)
{
  int i;

  if (INSN_P (insn))
    {
      rtx note;

      /* Record register defs.  */
      df_defs_record (df, PATTERN (insn), bb, insn);

      if (df->flags & DF_EQUIV_NOTES)
        for (note = REG_NOTES (insn); note;
             note = XEXP (note, 1))
          {
            switch (REG_NOTE_KIND (note))
              {
              case REG_EQUIV:
              case REG_EQUAL:
                df_uses_record (df, &XEXP (note, 0), DF_REF_REG_USE,
                                bb, insn, 0);
              default:
                break;
              }
          }

      if (CALL_P (insn))
        {
          rtx note;
          rtx x;

          /* Record the registers used to pass arguments.  */
          for (note = CALL_INSN_FUNCTION_USAGE (insn); note;
               note = XEXP (note, 1))
            {
              if (GET_CODE (XEXP (note, 0)) == USE)
                df_uses_record (df, &XEXP (XEXP (note, 0), 0), DF_REF_REG_USE,
                                bb, insn, 0);
            }

          /* The stack ptr is used (honorarily) by a CALL insn.  */
          x = df_reg_use_gen (STACK_POINTER_REGNUM);
          df_uses_record (df, &XEXP (x, 0), DF_REF_REG_USE, bb, insn, 0);

          if (df->flags & DF_HARD_REGS)
            {
              /* Calls may also reference any of the global registers,
                 so they are recorded as used.  */
              for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
                if (global_regs[i])
                  {
                    x = df_reg_use_gen (i);
                    df_uses_record (df, &SET_DEST (x),
                                    DF_REF_REG_USE, bb, insn, 0);
                  }
            }
        }

      /* Record the register uses.  */
      df_uses_record (df, &PATTERN (insn),
                      DF_REF_REG_USE, bb, insn, 0);

      if (CALL_P (insn))
        {
          rtx note;

          /* We do not record hard registers clobbered by the call,
             since there are awfully many of them and "defs" created
             through them are not interesting (since no use can be legally
             reached by them).  So we must just make sure we include them when
             computing kill bitmaps.  */

          /* There may be extra registers to be clobbered.  */
          for (note = CALL_INSN_FUNCTION_USAGE (insn);
               note;
               note = XEXP (note, 1))
            if (GET_CODE (XEXP (note, 0)) == CLOBBER)
              df_defs_record (df, XEXP (note, 0), bb, insn);
        }
    }
}


/* Record all the refs within the basic block BB.  */
static void
df_bb_refs_record (struct df *df, basic_block bb)
{
  rtx insn;

  /* Scan the block an insn at a time from beginning to end.  */
  FOR_BB_INSNS (bb, insn)
    {
      if (INSN_P (insn))
        {
          /* Record defs within INSN.  */
          df_insn_refs_record (df, bb, insn);
        }
    }
}


/* Record all the refs in the basic blocks specified by BLOCKS.  */
static void
df_refs_record (struct df *df, bitmap blocks)
{
  basic_block bb;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      df_bb_refs_record (df, bb);
    });
}
\f
/* Dataflow analysis routines.  */

/* Create reg-def chains for basic block BB.  These are a list of
   definitions for each register.  */

static void
df_bb_reg_def_chain_create (struct df *df, basic_block bb)
{
  rtx insn;

  /* Perhaps the defs should be sorted using a depth first search
     of the CFG (or possibly a breadth first search).  */

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      struct df_link *link;
      unsigned int uid = INSN_UID (insn);

      if (! INSN_P (insn))
        continue;

      for (link = df->insns[uid].defs; link; link = link->next)
        {
          struct ref *def = link->ref;
          unsigned int dregno = DF_REF_REGNO (def);

          /* Do not add ref's to the chain twice, i.e., only add new
             refs.  XXX the same could be done by testing if the
             current insn is a modified (or a new) one.  This would be
             faster.  */
          if (DF_REF_ID (def) < df->def_id_save)
            continue;

          df->regs[dregno].defs = df_link_create (def, df->regs[dregno].defs);
        }
    }
}


/* Create reg-def chains for each basic block within BLOCKS.  These
   are a list of definitions for each register.  If REDO is true, add
   all defs, otherwise just add the new defs.  */

static void
df_reg_def_chain_create (struct df *df, bitmap blocks, bool redo)
{
  basic_block bb;
#ifdef ENABLE_CHECKING
  unsigned regno;
#endif
  unsigned old_def_id_save = df->def_id_save;

  if (redo)
    {
#ifdef ENABLE_CHECKING
      for (regno = 0; regno < df->n_regs; regno++)
        gcc_assert (!df->regs[regno].defs);
#endif

      /* Pretend that all defs are new.  */
      df->def_id_save = 0;
    }

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      df_bb_reg_def_chain_create (df, bb);
    });

  df->def_id_save = old_def_id_save;
}

/* Remove all reg-def chains stored in the dataflow object DF.  */

static void
df_reg_def_chain_clean (struct df *df)
{
  unsigned regno;

  for (regno = 0; regno < df->n_regs; regno++)
    free_reg_ref_chain (&df->regs[regno].defs);
}

/* Create reg-use chains for basic block BB.  These are a list of uses
   for each register.  */

static void
df_bb_reg_use_chain_create (struct df *df, basic_block bb)
{
  rtx insn;

  /* Scan in forward order so that the last uses appear at the start
     of the chain.  */

  FOR_BB_INSNS (bb, insn)
    {
      struct df_link *link;
      unsigned int uid = INSN_UID (insn);

      if (! INSN_P (insn))
        continue;

      for (link = df->insns[uid].uses; link; link = link->next)
        {
          struct ref *use = link->ref;
          unsigned int uregno = DF_REF_REGNO (use);

          /* Do not add ref's to the chain twice, i.e., only add new
             refs.  XXX the same could be done by testing if the
             current insn is a modified (or a new) one.  This would be
             faster.  */
          if (DF_REF_ID (use) < df->use_id_save)
            continue;

          df->regs[uregno].uses
            = df_link_create (use, df->regs[uregno].uses);
        }
    }
}


/* Create reg-use chains for each basic block within BLOCKS.  These
   are a list of uses for each register.  If REDO is true, remove the
   old reg-use chains first, otherwise just add new uses to them.  */

static void
df_reg_use_chain_create (struct df *df, bitmap blocks, bool redo)
{
  basic_block bb;
#ifdef ENABLE_CHECKING
  unsigned regno;
#endif
  unsigned old_use_id_save = df->use_id_save;

  if (redo)
    {
#ifdef ENABLE_CHECKING
      for (regno = 0; regno < df->n_regs; regno++)
        gcc_assert (!df->regs[regno].uses);
#endif

      /* Pretend that all uses are new.  */
      df->use_id_save = 0;
    }

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      df_bb_reg_use_chain_create (df, bb);
    });

  df->use_id_save = old_use_id_save;
}

/* Remove all reg-use chains stored in the dataflow object DF.  */

static void
df_reg_use_chain_clean (struct df *df)
{
  unsigned regno;

  for (regno = 0; regno < df->n_regs; regno++)
    free_reg_ref_chain (&df->regs[regno].uses);
}

/* Create def-use chains from reaching use bitmaps for basic block BB.  */
static void
df_bb_du_chain_create (struct df *df, basic_block bb, bitmap ru)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  rtx insn;

  bitmap_copy (ru, bb_info->ru_out);

  /* For each def in BB create a linked list (chain) of uses
     reached from the def.  */
  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      struct df_link *def_link;
      struct df_link *use_link;
      unsigned int uid = INSN_UID (insn);

      if (! INSN_P (insn))
        continue;

      /* For each def in insn...  */
      for (def_link = df->insns[uid].defs; def_link; def_link = def_link->next)
        {
          struct ref *def = def_link->ref;
          unsigned int dregno = DF_REF_REGNO (def);

          DF_REF_CHAIN (def) = 0;

          /* While the reg-use chains are not essential, it
             is _much_ faster to search these short lists rather
             than all the reaching uses, especially for large functions.  */
          for (use_link = df->regs[dregno].uses; use_link;
               use_link = use_link->next)
            {
              struct ref *use = use_link->ref;

              if (bitmap_bit_p (ru, DF_REF_ID (use)))
                {
                  DF_REF_CHAIN (def)
                    = df_link_create (use, DF_REF_CHAIN (def));

                  bitmap_clear_bit (ru, DF_REF_ID (use));
                }
            }
        }

      /* For each use in insn...  */
      for (use_link = df->insns[uid].uses; use_link; use_link = use_link->next)
        {
          struct ref *use = use_link->ref;
          bitmap_set_bit (ru, DF_REF_ID (use));
        }
    }
}


/* Create def-use chains from reaching use bitmaps for basic blocks
   in BLOCKS.  */
static void
df_du_chain_create (struct df *df, bitmap blocks)
{
  bitmap ru;
  basic_block bb;

  ru = BITMAP_XMALLOC ();

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      df_bb_du_chain_create (df, bb, ru);
    });

  BITMAP_XFREE (ru);
}


/* Create use-def chains from reaching def bitmaps for basic block BB.  */
static void
df_bb_ud_chain_create (struct df *df, basic_block bb)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  struct ref **reg_def_last = df->reg_def_last;
  rtx insn;

  memset (reg_def_last, 0, df->n_regs * sizeof (struct ref *));

  /* For each use in BB create a linked list (chain) of defs
     that reach the use.  */
  FOR_BB_INSNS (bb, insn)
    {
      unsigned int uid = INSN_UID (insn);
      struct df_link *use_link;
      struct df_link *def_link;

      if (! INSN_P (insn))
        continue;

      /* For each use in insn...  */
      for (use_link = df->insns[uid].uses; use_link; use_link = use_link->next)
        {
          struct ref *use = use_link->ref;
          unsigned int regno = DF_REF_REGNO (use);

          DF_REF_CHAIN (use) = 0;

          /* Has regno been defined in this BB yet?  If so, use
             the last def as the single entry for the use-def
             chain for this use.  Otherwise, we need to add all
             the defs using this regno that reach the start of
             this BB.  */
          if (reg_def_last[regno])
            {
              DF_REF_CHAIN (use)
                = df_link_create (reg_def_last[regno], 0);
            }
          else
            {
              /* While the reg-def chains are not essential, it is
                 _much_ faster to search these short lists rather than
                 all the reaching defs, especially for large
                 functions.  */
              for (def_link = df->regs[regno].defs; def_link;
                   def_link = def_link->next)
                {
                  struct ref *def = def_link->ref;

                  if (bitmap_bit_p (bb_info->rd_in, DF_REF_ID (def)))
                    {
                      DF_REF_CHAIN (use)
                        = df_link_create (def, DF_REF_CHAIN (use));
                    }
                }
            }
        }


      /* For each def in insn... record the last def of each reg.  */
      for (def_link = df->insns[uid].defs; def_link; def_link = def_link->next)
        {
          struct ref *def = def_link->ref;
          int dregno = DF_REF_REGNO (def);

          reg_def_last[dregno] = def;
        }
    }
}


/* Create use-def chains from reaching def bitmaps for basic blocks
   within BLOCKS.  */
static void
df_ud_chain_create (struct df *df, bitmap blocks)
{
  basic_block bb;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      df_bb_ud_chain_create (df, bb);
    });
}
\f


static void
df_rd_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, void *in,
                         void *out, void *gen, void *kill,
                         void *data ATTRIBUTE_UNUSED)
{
  *changed = bitmap_ior_and_compl (out, gen, in, kill);
}


static void
df_ru_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, void *in,
                         void *out, void *gen, void *kill,
                         void *data ATTRIBUTE_UNUSED)
{
  *changed = bitmap_ior_and_compl (in, gen, out, kill);
}


static void
df_lr_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, void *in,
                         void *out, void *use, void *def,
                         void *data ATTRIBUTE_UNUSED)
{
  *changed = bitmap_ior_and_compl (in, use, out, def);
}


/* Compute local reaching def info for basic block BB.  */
static void
df_bb_rd_local_compute (struct df *df, basic_block bb, bitmap call_killed_defs)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  rtx insn;
  bitmap seen = BITMAP_XMALLOC ();
  bool call_seen = false;

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      unsigned int uid = INSN_UID (insn);
      struct df_link *def_link;

      if (! INSN_P (insn))
        continue;

      for (def_link = df->insns[uid].defs; def_link; def_link = def_link->next)
        {
          struct ref *def = def_link->ref;
          unsigned int regno = DF_REF_REGNO (def);
          struct df_link *def2_link;

          if (bitmap_bit_p (seen, regno)
              || (call_seen
                  && regno < FIRST_PSEUDO_REGISTER
                  && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)))
            continue;

          for (def2_link = df->regs[regno].defs; def2_link;
               def2_link = def2_link->next)
            {
              struct ref *def2 = def2_link->ref;

              /* Add all defs of this reg to the set of kills.  This
                 is greedy since many of these defs will not actually
                 be killed by this BB but it keeps things a lot
                 simpler.  */
              bitmap_set_bit (bb_info->rd_kill, DF_REF_ID (def2));
            }

          bitmap_set_bit (bb_info->rd_gen, DF_REF_ID (def));
          bitmap_set_bit (seen, regno);
        }

      if (CALL_P (insn) && (df->flags & DF_HARD_REGS))
        {
          bitmap_ior_into (bb_info->rd_kill, call_killed_defs);
          call_seen = 1;
        }
    }

  BITMAP_XFREE (seen);
}


/* Compute local reaching def info for each basic block within BLOCKS.  */
static void
df_rd_local_compute (struct df *df, bitmap blocks)
{
  basic_block bb;
  bitmap killed_by_call = NULL;
  unsigned regno;
  struct df_link *def_link;

  if (df->flags & DF_HARD_REGS)
    {
      killed_by_call = BITMAP_XMALLOC ();
      for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        {
          if (!TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
            continue;
          
          for (def_link = df->regs[regno].defs;
               def_link;
               def_link = def_link->next)
            bitmap_set_bit (killed_by_call, DF_REF_ID (def_link->ref));
        }
    }

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
  {
    df_bb_rd_local_compute (df, bb, killed_by_call);
  });

  if (df->flags & DF_HARD_REGS)
    BITMAP_XFREE (killed_by_call);
}


/* Compute local reaching use (upward exposed use) info for basic
   block BB.  */
static void
df_bb_ru_local_compute (struct df *df, basic_block bb)
{
  /* This is much more tricky than computing reaching defs.  With
     reaching defs, defs get killed by other defs.  With upwards
     exposed uses, these get killed by defs with the same regno.  */

  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  rtx insn;


  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      unsigned int uid = INSN_UID (insn);
      struct df_link *def_link;
      struct df_link *use_link;

      if (! INSN_P (insn))
        continue;

      for (def_link = df->insns[uid].defs; def_link; def_link = def_link->next)
        {
          struct ref *def = def_link->ref;
          unsigned int dregno = DF_REF_REGNO (def);

          for (use_link = df->regs[dregno].uses; use_link;
               use_link = use_link->next)
            {
              struct ref *use = use_link->ref;

              /* Add all uses of this reg to the set of kills.  This
                 is greedy since many of these uses will not actually
                 be killed by this BB but it keeps things a lot
                 simpler.  */
              bitmap_set_bit (bb_info->ru_kill, DF_REF_ID (use));

              /* Zap from the set of gens for this BB.  */
              bitmap_clear_bit (bb_info->ru_gen, DF_REF_ID (use));
            }
        }

      for (use_link = df->insns[uid].uses; use_link; use_link = use_link->next)
        {
          struct ref *use = use_link->ref;
          /* Add use to set of gens in this BB.  */
          bitmap_set_bit (bb_info->ru_gen, DF_REF_ID (use));
        }
    }
}


/* Compute local reaching use (upward exposed use) info for each basic
   block within BLOCKS.  */
static void
df_ru_local_compute (struct df *df, bitmap blocks)
{
  basic_block bb;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
  {
    df_bb_ru_local_compute (df, bb);
  });
}


/* Compute local live variable info for basic block BB.  */
static void
df_bb_lr_local_compute (struct df *df, basic_block bb)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  rtx insn;

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      unsigned int uid = INSN_UID (insn);
      struct df_link *link;

      if (! INSN_P (insn))
        continue;

      for (link = df->insns[uid].defs; link; link = link->next)
        {
          struct ref *def = link->ref;
          unsigned int dregno = DF_REF_REGNO (def);

          /* Add def to set of defs in this BB.  */
          bitmap_set_bit (bb_info->lr_def, dregno);

          bitmap_clear_bit (bb_info->lr_use, dregno);
        }

      for (link = df->insns[uid].uses; link; link = link->next)
        {
          struct ref *use = link->ref;
          /* Add use to set of uses in this BB.  */
          bitmap_set_bit (bb_info->lr_use, DF_REF_REGNO (use));
        }
    }
}


/* Compute local live variable info for each basic block within BLOCKS.  */
static void
df_lr_local_compute (struct df *df, bitmap blocks)
{
  basic_block bb;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
  {
    df_bb_lr_local_compute (df, bb);
  });
}


/* Compute register info: lifetime, bb, and number of defs and uses
   for basic block BB.  */
static void
df_bb_reg_info_compute (struct df *df, basic_block bb, bitmap live)
{
  struct reg_info *reg_info = df->regs;
  struct bb_info *bb_info = DF_BB_INFO (df, bb);
  rtx insn;

  bitmap_copy (live, bb_info->lr_out);

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      unsigned int uid = INSN_UID (insn);
      unsigned int regno;
      struct df_link *link;
      bitmap_iterator bi;

      if (! INSN_P (insn))
        continue;

      for (link = df->insns[uid].defs; link; link = link->next)
        {
          struct ref *def = link->ref;
          unsigned int dregno = DF_REF_REGNO (def);

          /* Kill this register.  */
          bitmap_clear_bit (live, dregno);
          reg_info[dregno].n_defs++;
        }

      for (link = df->insns[uid].uses; link; link = link->next)
        {
          struct ref *use = link->ref;
          unsigned int uregno = DF_REF_REGNO (use);

          /* This register is now live.  */
          bitmap_set_bit (live, uregno);
          reg_info[uregno].n_uses++;
        }

      /* Increment lifetimes of all live registers.  */
      EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
        {
          reg_info[regno].lifetime++;
        }
    }
}


/* Compute register info: lifetime, bb, and number of defs and uses.  */
static void
df_reg_info_compute (struct df *df, bitmap blocks)
{
  basic_block bb;
  bitmap live;

  live = BITMAP_XMALLOC ();

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
  {
    df_bb_reg_info_compute (df, bb, live);
  });

  BITMAP_XFREE (live);
}


/* Assign LUIDs for BB.  */
static int
df_bb_luids_set (struct df *df, basic_block bb)
{
  rtx insn;
  int luid = 0;

  /* The LUIDs are monotonically increasing for each basic block.  */

  FOR_BB_INSNS (bb, insn)
    {
      if (INSN_P (insn))
        DF_INSN_LUID (df, insn) = luid++;
      DF_INSN_LUID (df, insn) = luid;
    }
  return luid;
}


/* Assign LUIDs for each basic block within BLOCKS.  */
static int
df_luids_set (struct df *df, bitmap blocks)
{
  basic_block bb;
  int total = 0;

  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      total += df_bb_luids_set (df, bb);
    });
  return total;
}


/* Perform dataflow analysis using existing DF structure for blocks
   within BLOCKS.  If BLOCKS is zero, use all basic blocks in the CFG.  */
static void
df_analyze_1 (struct df *df, bitmap blocks, int flags, int update)
{
  int aflags;
  int dflags;
  int i;
  basic_block bb;
  struct dataflow dflow;

  dflags = 0;
  aflags = flags;
  if (flags & DF_UD_CHAIN)
    aflags |= DF_RD | DF_RD_CHAIN;

  if (flags & DF_DU_CHAIN)
    aflags |= DF_RU;

  if (flags & DF_RU)
    aflags |= DF_RU_CHAIN;

  if (flags & DF_REG_INFO)
    aflags |= DF_LR;

  if (! blocks)
    blocks = df->all_blocks;

  df->flags = flags;
  if (update)
    {
      df_refs_update (df, NULL);
      /* More fine grained incremental dataflow analysis would be
         nice.  For now recompute the whole shebang for the
         modified blocks.  */
#if 0
      df_refs_unlink (df, blocks);
#endif
      /* All the def-use, use-def chains can be potentially
         modified by changes in one block.  The size of the
         bitmaps can also change.  */
    }
  else
    {
      /* Scan the function for all register defs and uses.  */
      df_refs_queue (df);
      df_refs_record (df, blocks);

      /* Link all the new defs and uses to the insns.  */
      df_refs_process (df);
    }

  /* Allocate the bitmaps now the total number of defs and uses are
     known.  If the number of defs or uses have changed, then
     these bitmaps need to be reallocated.  */
  df_bitmaps_alloc (df, NULL, aflags);

  /* Set the LUIDs for each specified basic block.  */
  df_luids_set (df, blocks);

  /* Recreate reg-def and reg-use chains from scratch so that first
     def is at the head of the reg-def chain and the last use is at
     the head of the reg-use chain.  This is only important for
     regs local to a basic block as it speeds up searching.  */
  if (aflags & DF_RD_CHAIN)
    {
      df_reg_def_chain_create (df, blocks, false);
    }

  if (aflags & DF_RU_CHAIN)
    {
      df_reg_use_chain_create (df, blocks, false);
    }

  df->dfs_order = xmalloc (sizeof (int) * n_basic_blocks);
  df->rc_order = xmalloc (sizeof (int) * n_basic_blocks);
  df->rts_order = xmalloc (sizeof (int) * n_basic_blocks);
  df->inverse_dfs_map = xmalloc (sizeof (int) * last_basic_block);
  df->inverse_rc_map = xmalloc (sizeof (int) * last_basic_block);
  df->inverse_rts_map = xmalloc (sizeof (int) * last_basic_block);

  flow_depth_first_order_compute (df->dfs_order, df->rc_order);
  flow_reverse_top_sort_order_compute (df->rts_order);
  for (i = 0; i < n_basic_blocks; i++)
    {
      df->inverse_dfs_map[df->dfs_order[i]] = i;
      df->inverse_rc_map[df->rc_order[i]] = i;
      df->inverse_rts_map[df->rts_order[i]] = i;
    }
  if (aflags & DF_RD)
    {
      /* Compute the sets of gens and kills for the defs of each bb.  */
      dflow.in = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.out = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.gen = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.kill = xmalloc (sizeof (bitmap) * last_basic_block);

      df_rd_local_compute (df, df->flags & DF_RD ? blocks : df->all_blocks);
      FOR_EACH_BB (bb)
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->rd_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->rd_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->rd_gen;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->rd_kill;
        }

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_FORWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_rd_transfer_function;
      dflow.n_blocks = n_basic_blocks;
      dflow.order = df->rc_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
      free (dflow.in);
      free (dflow.out);
      free (dflow.gen);
      free (dflow.kill);
    }

  if (aflags & DF_UD_CHAIN)
    {
      /* Create use-def chains.  */
      df_ud_chain_create (df, df->all_blocks);

      if (! (flags & DF_RD))
        dflags |= DF_RD;
    }

  if (aflags & DF_RU)
    {
      /* Compute the sets of gens and kills for the upwards exposed
         uses in each bb.  */
      dflow.in = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.out = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.gen = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.kill = xmalloc (sizeof (bitmap) * last_basic_block);

      df_ru_local_compute (df, df->flags & DF_RU ? blocks : df->all_blocks);

      FOR_EACH_BB (bb)
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->ru_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->ru_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->ru_gen;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->ru_kill;
        }

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_BACKWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_ru_transfer_function;
      dflow.n_blocks = n_basic_blocks;
      dflow.order = df->rts_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
      free (dflow.in);
      free (dflow.out);
      free (dflow.gen);
      free (dflow.kill);
    }

  if (aflags & DF_DU_CHAIN)
    {
      /* Create def-use chains.  */
      df_du_chain_create (df, df->all_blocks);

      if (! (flags & DF_RU))
        dflags |= DF_RU;
    }

  /* Free up bitmaps that are no longer required.  */
  if (dflags)
    df_bitmaps_free (df, dflags);

  if (aflags & DF_LR)
    {
      /* Compute the sets of defs and uses of live variables.  */
      dflow.in = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.out = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.gen = xmalloc (sizeof (bitmap) * last_basic_block);
      dflow.kill = xmalloc (sizeof (bitmap) * last_basic_block);

      df_lr_local_compute (df, df->flags & DF_LR ? blocks : df->all_blocks);

      FOR_EACH_BB (bb)
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->lr_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->lr_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->lr_use;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->lr_def;
        }

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_BACKWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_lr_transfer_function;
      dflow.n_blocks = n_basic_blocks;
      dflow.order = df->rts_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
      free (dflow.in);
      free (dflow.out);
      free (dflow.gen);
      free (dflow.kill);
    }

  if (aflags & DF_REG_INFO)
    {
      df_reg_info_compute (df, df->all_blocks);
    }

  free (df->dfs_order);
  free (df->rc_order);
  free (df->rts_order);
  free (df->inverse_rc_map);
  free (df->inverse_dfs_map);
  free (df->inverse_rts_map);
}


/* Initialize dataflow analysis.  */
struct df *
df_init (void)
{
  struct df *df;

  df = xcalloc (1, sizeof (struct df));

  /* Squirrel away a global for debugging.  */
  ddf = df;

  return df;
}


/* Start queuing refs.  */
static int
df_refs_queue (struct df *df)
{
  df->def_id_save = df->def_id;
  df->use_id_save = df->use_id;
  /* ???? Perhaps we should save current obstack state so that we can
     unwind it.  */
  return 0;
}


/* Process queued refs.  */
static int
df_refs_process (struct df *df)
{
  unsigned int i;

  /* Build new insn-def chains.  */
  for (i = df->def_id_save; i != df->def_id; i++)
    {
      struct ref *def = df->defs[i];
      unsigned int uid = DF_REF_INSN_UID (def);

      /* Add def to head of def list for INSN.  */
      df->insns[uid].defs
        = df_link_create (def, df->insns[uid].defs);
    }

  /* Build new insn-use chains.  */
  for (i = df->use_id_save; i != df->use_id; i++)
    {
      struct ref *use = df->uses[i];
      unsigned int uid = DF_REF_INSN_UID (use);

      /* Add use to head of use list for INSN.  */
      df->insns[uid].uses
        = df_link_create (use, df->insns[uid].uses);
    }
  return 0;
}


/* Update refs for basic block BB.  */
static int
df_bb_refs_update (struct df *df, basic_block bb)
{
  rtx insn;
  int count = 0;

  /* While we have to scan the chain of insns for this BB, we do not
     need to allocate and queue a long chain of BB/INSN pairs.  Using
     a bitmap for insns_modified saves memory and avoids queuing
     duplicates.  */

  FOR_BB_INSNS (bb, insn)
    {
      unsigned int uid;

      uid = INSN_UID (insn);

      if (bitmap_bit_p (df->insns_modified, uid))
        {
          /* Delete any allocated refs of this insn.  MPH,  FIXME.  */
          df_insn_refs_unlink (df, bb, insn);

          /* Scan the insn for refs.  */
          df_insn_refs_record (df, bb, insn);

          count++;
        }
    }
  return count;
}


/* Process all the modified/deleted insns that were queued.  */
static int
df_refs_update (struct df *df, bitmap blocks)
{
  basic_block bb;
  unsigned count = 0, bbno;

  df->n_regs = max_reg_num ();
  if (df->n_regs >= df->reg_size)
    df_reg_table_realloc (df, 0);

  df_refs_queue (df);

  if (!blocks)
    {
      FOR_EACH_BB_IN_BITMAP (df->bbs_modified, 0, bb,
        {
          count += df_bb_refs_update (df, bb);
        });
    }
  else
    {
      bitmap_iterator bi;

      EXECUTE_IF_AND_IN_BITMAP (df->bbs_modified, blocks, 0, bbno, bi)
        {
          count += df_bb_refs_update (df, BASIC_BLOCK (bbno));
        }
    }

  df_refs_process (df);
  return count;
}


/* Return nonzero if any of the requested blocks in the bitmap
   BLOCKS have been modified.  */
static int
df_modified_p (struct df *df, bitmap blocks)
{
  int update = 0;
  basic_block bb;

  if (!df->n_bbs)
    return 0;

  FOR_EACH_BB (bb)
    if (bitmap_bit_p (df->bbs_modified, bb->index)
        && (! blocks || (blocks == (bitmap) -1) || bitmap_bit_p (blocks, bb->index)))
    {
      update = 1;
      break;
    }

  return update;
}

/* Analyze dataflow info for the basic blocks specified by the bitmap
   BLOCKS, or for the whole CFG if BLOCKS is zero, or just for the
   modified blocks if BLOCKS is -1.  */

int
df_analyze (struct df *df, bitmap blocks, int flags)
{
  int update;

  /* We could deal with additional basic blocks being created by
     rescanning everything again.  */
  gcc_assert (!df->n_bbs || df->n_bbs == (unsigned int) last_basic_block);

  update = df_modified_p (df, blocks);
  if (update || (flags != df->flags))
    {
      if (! blocks)
        {
          if (df->n_bbs)
            {
              /* Recompute everything from scratch.  */
              df_free (df);
            }
          /* Allocate and initialize data structures.  */
          df_alloc (df, max_reg_num ());
          df_analyze_1 (df, 0, flags, 0);
          update = 1;
        }
      else
        {
          if (blocks == (bitmap) -1)
            blocks = df->bbs_modified;

          gcc_assert (df->n_bbs);

          df_analyze_1 (df, blocks, flags, 1);
          bitmap_zero (df->bbs_modified);
          bitmap_zero (df->insns_modified);
        }
    }
  return update;
}

/* Remove the entries not in BLOCKS from the LIST of length LEN, preserving
   the order of the remaining entries.  Returns the length of the resulting
   list.  */

static unsigned
prune_to_subcfg (int list[], unsigned len, bitmap blocks)
{
  unsigned act, last;

  for (act = 0, last = 0; act < len; act++)
    if (bitmap_bit_p (blocks, list[act]))
      list[last++] = list[act];

  return last;
}

/* Alternative entry point to the analysis.  Analyze just the part of the cfg
   graph induced by BLOCKS.
   
   TODO I am not quite sure how to avoid code duplication with df_analyze_1
   here, and simultaneously not make even greater chaos in it.  We behave
   slightly differently in some details, especially in handling modified
   insns.  */

void
df_analyze_subcfg (struct df *df, bitmap blocks, int flags)
{
  rtx insn;
  basic_block bb;
  struct dataflow dflow;
  unsigned n_blocks;

  if (flags & DF_UD_CHAIN)
    flags |= DF_RD | DF_RD_CHAIN;
  if (flags & DF_DU_CHAIN)
    flags |= DF_RU;
  if (flags & DF_RU)
    flags |= DF_RU_CHAIN;
  if (flags & DF_REG_INFO)
    flags |= DF_LR;

  if (!df->n_bbs)
    {
      df_alloc (df, max_reg_num ());

      /* Mark all insns as modified.  */

      FOR_EACH_BB (bb)
        {
          FOR_BB_INSNS (bb, insn)
            {
              df_insn_modify (df, bb, insn);
            }
        }
    }
  
  df->flags = flags;

  df_reg_def_chain_clean (df);
  df_reg_use_chain_clean (df);

  df_refs_update (df, blocks);

  /* Clear the updated stuff from ``modified'' bitmaps.  */
  FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
    {
      if (bitmap_bit_p (df->bbs_modified, bb->index))
        {
          FOR_BB_INSNS (bb, insn)
            {
              bitmap_clear_bit (df->insns_modified, INSN_UID (insn));
            }

          bitmap_clear_bit (df->bbs_modified, bb->index);
        }
    });

  /* Allocate the bitmaps now the total number of defs and uses are
     known.  If the number of defs or uses have changed, then
     these bitmaps need to be reallocated.  */
  df_bitmaps_alloc (df, blocks, flags);

  /* Set the LUIDs for each specified basic block.  */
  df_luids_set (df, blocks);

  /* Recreate reg-def and reg-use chains from scratch so that first
     def is at the head of the reg-def chain and the last use is at
     the head of the reg-use chain.  This is only important for
     regs local to a basic block as it speeds up searching.  */
  if (flags & DF_RD_CHAIN)
    {
      df_reg_def_chain_create (df, blocks, true);
    }

  if (flags & DF_RU_CHAIN)
    {
      df_reg_use_chain_create (df, blocks, true);
    }

  df->dfs_order = xmalloc (sizeof (int) * n_basic_blocks);
  df->rc_order = xmalloc (sizeof (int) * n_basic_blocks);
  df->rts_order = xmalloc (sizeof (int) * n_basic_blocks);

  flow_depth_first_order_compute (df->dfs_order, df->rc_order);
  flow_reverse_top_sort_order_compute (df->rts_order);

  n_blocks = prune_to_subcfg (df->dfs_order, n_basic_blocks, blocks);
  prune_to_subcfg (df->rc_order, n_basic_blocks, blocks);
  prune_to_subcfg (df->rts_order, n_basic_blocks, blocks);

  dflow.in = xmalloc (sizeof (bitmap) * last_basic_block);
  dflow.out = xmalloc (sizeof (bitmap) * last_basic_block);
  dflow.gen = xmalloc (sizeof (bitmap) * last_basic_block);
  dflow.kill = xmalloc (sizeof (bitmap) * last_basic_block);

  if (flags & DF_RD)
    {
      /* Compute the sets of gens and kills for the defs of each bb.  */
      df_rd_local_compute (df, blocks);

      FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->rd_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->rd_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->rd_gen;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->rd_kill;
        });

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_FORWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_rd_transfer_function;
      dflow.n_blocks = n_blocks;
      dflow.order = df->rc_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
    }

  if (flags & DF_UD_CHAIN)
    {
      /* Create use-def chains.  */
      df_ud_chain_create (df, blocks);
    }

  if (flags & DF_RU)
    {
      /* Compute the sets of gens and kills for the upwards exposed
         uses in each bb.  */
      df_ru_local_compute (df, blocks);

      FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->ru_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->ru_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->ru_gen;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->ru_kill;
        });

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_BACKWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_ru_transfer_function;
      dflow.n_blocks = n_blocks;
      dflow.order = df->rts_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
    }

  if (flags & DF_DU_CHAIN)
    {
      /* Create def-use chains.  */
      df_du_chain_create (df, blocks);
    }

  if (flags & DF_LR)
    {
      /* Compute the sets of defs and uses of live variables.  */
      df_lr_local_compute (df, blocks);

      FOR_EACH_BB (bb)
        {
          dflow.in[bb->index] = DF_BB_INFO (df, bb)->lr_in;
          dflow.out[bb->index] = DF_BB_INFO (df, bb)->lr_out;
          dflow.gen[bb->index] = DF_BB_INFO (df, bb)->lr_use;
          dflow.kill[bb->index] = DF_BB_INFO (df, bb)->lr_def;
        }

      dflow.repr = SR_BITMAP;
      dflow.dir = DF_BACKWARD;
      dflow.conf_op = DF_UNION;
      dflow.transfun = df_lr_transfer_function;
      dflow.n_blocks = n_blocks;
      dflow.order = df->rts_order;
      dflow.data = NULL;

      iterative_dataflow (&dflow);
    }

  if (flags & DF_REG_INFO)
    {
      df_reg_info_compute (df, blocks);
    }

  free (dflow.in);
  free (dflow.out);
  free (dflow.gen);
  free (dflow.kill);

  free (df->dfs_order);
  free (df->rc_order);
  free (df->rts_order);
}

/* Free all the dataflow info and the DF structure.  */
void
df_finish (struct df *df)
{
  df_free (df);
  free (df);
}

/* Unlink INSN from its reference information.  */
static void
df_insn_refs_unlink (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
{
  struct df_link *link;
  unsigned int uid;

  uid = INSN_UID (insn);

  /* Unlink all refs defined by this insn.  */
  for (link = df->insns[uid].defs; link; link = link->next)
    df_def_unlink (df, link->ref);

  /* Unlink all refs used by this insn.  */
  for (link = df->insns[uid].uses; link; link = link->next)
    df_use_unlink (df, link->ref);

  df->insns[uid].defs = 0;
  df->insns[uid].uses = 0;
}


#if 0
/* Unlink all the insns within BB from their reference information.  */
static void
df_bb_refs_unlink (struct df *df, basic_block bb)
{
  rtx insn;

  /* Scan the block an insn at a time from beginning to end.  */
  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
    {
      if (INSN_P (insn))
        {
          /* Unlink refs for INSN.  */
          df_insn_refs_unlink (df, bb, insn);
        }
      if (insn == BB_END (bb))
        break;
    }
}


/* Unlink all the refs in the basic blocks specified by BLOCKS.
   Not currently used.  */
static void
df_refs_unlink (struct df *df, bitmap blocks)
{
  basic_block bb;

  if (blocks)
    {
      FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
      {
        df_bb_refs_unlink (df, bb);
      });
    }
  else
    {
      FOR_EACH_BB (bb)
        df_bb_refs_unlink (df, bb);
    }
}
#endif
\f
/* Functions to modify insns.  */


/* Delete INSN and all its reference information.  */
rtx
df_insn_delete (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
{
  /* If the insn is a jump, we should perhaps call delete_insn to
     handle the JUMP_LABEL?  */

  /* We should not be deleting the NOTE_INSN_BASIC_BLOCK or label.  */
  gcc_assert (insn != BB_HEAD (bb));

  /* Delete the insn.  */
  delete_insn (insn);

  df_insn_modify (df, bb, insn);

  return NEXT_INSN (insn);
}

/* Mark that basic block BB was modified.  */

static void
df_bb_modify (struct df *df, basic_block bb)
{
  if ((unsigned) bb->index >= df->n_bbs)
    df_bb_table_realloc (df, df->n_bbs);

  bitmap_set_bit (df->bbs_modified, bb->index);
}

/* Mark that INSN within BB may have changed  (created/modified/deleted).
   This may be called multiple times for the same insn.  There is no
   harm calling this function if the insn wasn't changed; it will just
   slow down the rescanning of refs.  */
void
df_insn_modify (struct df *df, basic_block bb, rtx insn)
{
  unsigned int uid;

  uid = INSN_UID (insn);
  if (uid >= df->insn_size)
    df_insn_table_realloc (df, uid);

  df_bb_modify (df, bb);
  bitmap_set_bit (df->insns_modified, uid);

  /* For incremental updating on the fly, perhaps we could make a copy
     of all the refs of the original insn and turn them into
     anti-refs.  When df_refs_update finds these anti-refs, it annihilates
     the original refs.  If validate_change fails then these anti-refs
     will just get ignored.  */
}

typedef struct replace_args
{
  rtx match;
  rtx replacement;
  rtx insn;
  int modified;
} replace_args;


/* Replace mem pointed to by PX with its associated pseudo register.
   DATA is actually a pointer to a structure describing the
   instruction currently being scanned and the MEM we are currently
   replacing.  */
static int
df_rtx_mem_replace (rtx *px, void *data)
{
  replace_args *args = (replace_args *) data;
  rtx mem = *px;

  if (mem == NULL_RTX)
    return 0;

  switch (GET_CODE (mem))
    {
    case MEM:
      break;

    case CONST_DOUBLE:
      /* We're not interested in the MEM associated with a
         CONST_DOUBLE, so there's no need to traverse into one.  */
      return -1;

    default:
      /* This is not a MEM.  */
      return 0;
    }

  if (!rtx_equal_p (args->match, mem))
    /* This is not the MEM we are currently replacing.  */
    return 0;

  /* Actually replace the MEM.  */
  validate_change (args->insn, px, args->replacement, 1);
  args->modified++;

  return 0;
}


int
df_insn_mem_replace (struct df *df, basic_block bb, rtx insn, rtx mem, rtx reg)
{
  replace_args args;

  args.insn = insn;
  args.match = mem;
  args.replacement = reg;
  args.modified = 0;

  /* Search and replace all matching mems within insn.  */
  for_each_rtx (&insn, df_rtx_mem_replace, &args);

  if (args.modified)
    df_insn_modify (df, bb, insn);

  /* ???? FIXME.  We may have a new def or one or more new uses of REG
     in INSN.  REG should be a new pseudo so it won't affect the
     dataflow information that we currently have.  We should add
     the new uses and defs to INSN and then recreate the chains
     when df_analyze is called.  */
  return args.modified;
}


/* Replace one register with another.  Called through for_each_rtx; PX
   points to the rtx being scanned.  DATA is actually a pointer to a
   structure of arguments.  */
static int
df_rtx_reg_replace (rtx *px, void *data)
{
  rtx x = *px;
  replace_args *args = (replace_args *) data;

  if (x == NULL_RTX)
    return 0;

  if (x == args->match)
    {
      validate_change (args->insn, px, args->replacement, 1);
      args->modified++;
    }

  return 0;
}


/* Replace the reg within every ref on CHAIN that is within the set
   BLOCKS of basic blocks with NEWREG.  Also update the regs within
   REG_NOTES.  */
void
df_refs_reg_replace (struct df *df, bitmap blocks, struct df_link *chain, rtx oldreg, rtx newreg)
{
  struct df_link *link;
  replace_args args;

  if (! blocks)
    blocks = df->all_blocks;

  args.match = oldreg;
  args.replacement = newreg;
  args.modified = 0;

  for (link = chain; link; link = link->next)
    {
      struct ref *ref = link->ref;
      rtx insn = DF_REF_INSN (ref);

      if (! INSN_P (insn))
        continue;

      gcc_assert (bitmap_bit_p (blocks, DF_REF_BBNO (ref)));
      
      df_ref_reg_replace (df, ref, oldreg, newreg);

      /* Replace occurrences of the reg within the REG_NOTES.  */
      if ((! link->next || DF_REF_INSN (ref)
           != DF_REF_INSN (link->next->ref))
          && REG_NOTES (insn))
        {
          args.insn = insn;
          for_each_rtx (&REG_NOTES (insn), df_rtx_reg_replace, &args);
        }
    }
}


/* Replace all occurrences of register OLDREG with register NEWREG in
   blocks defined by bitmap BLOCKS.  This also replaces occurrences of
   OLDREG in the REG_NOTES but only for insns containing OLDREG.  This
   routine expects the reg-use and reg-def chains to be valid.  */
int
df_reg_replace (struct df *df, bitmap blocks, rtx oldreg, rtx newreg)
{
  unsigned int oldregno = REGNO (oldreg);

  df_refs_reg_replace (df, blocks, df->regs[oldregno].defs, oldreg, newreg);
  df_refs_reg_replace (df, blocks, df->regs[oldregno].uses, oldreg, newreg);
  return 1;
}


/* Try replacing the reg within REF with NEWREG.  Do not modify
   def-use/use-def chains.  */
int
df_ref_reg_replace (struct df *df, struct ref *ref, rtx oldreg, rtx newreg)
{
  /* Check that insn was deleted by being converted into a NOTE.  If
   so ignore this insn.  */
  if (! INSN_P (DF_REF_INSN (ref)))
    return 0;

  gcc_assert (!oldreg || oldreg == DF_REF_REG (ref));

  if (! validate_change (DF_REF_INSN (ref), DF_REF_LOC (ref), newreg, 1))
    return 0;

  df_insn_modify (df, DF_REF_BB (ref), DF_REF_INSN (ref));
  return 1;
}


struct ref*
df_bb_def_use_swap (struct df *df, basic_block bb, rtx def_insn, rtx use_insn, unsigned int regno)
{
  struct ref *def;
  struct ref *use;
  int def_uid;
  int use_uid;
  struct df_link *link;

  def = df_bb_insn_regno_first_def_find (df, bb, def_insn, regno);
  if (! def)
    return 0;

  use = df_bb_insn_regno_last_use_find (df, bb, use_insn, regno);
  if (! use)
    return 0;

  /* The USE no longer exists.  */
  use_uid = INSN_UID (use_insn);
  df_use_unlink (df, use);
  df_ref_unlink (&df->insns[use_uid].uses, use);

  /* The DEF requires shifting so remove it from DEF_INSN
     and add it to USE_INSN by reusing LINK.  */
  def_uid = INSN_UID (def_insn);
  link = df_ref_unlink (&df->insns[def_uid].defs, def);
  link->ref = def;
  link->next = df->insns[use_uid].defs;
  df->insns[use_uid].defs = link;

#if 0
  link = df_ref_unlink (&df->regs[regno].defs, def);
  link->ref = def;
  link->next = df->regs[regno].defs;
  df->insns[regno].defs = link;
#endif

  DF_REF_INSN (def) = use_insn;
  return def;
}


/* Record df between FIRST_INSN and LAST_INSN inclusive.  All new
   insns must be processed by this routine.  */
static void
df_insns_modify (struct df *df, basic_block bb, rtx first_insn, rtx last_insn)
{
  rtx insn;

  for (insn = first_insn; ; insn = NEXT_INSN (insn))
    {
      unsigned int uid;

      /* A non-const call should not have slipped through the net.  If
         it does, we need to create a new basic block.  Ouch.  The
         same applies for a label.  */
      gcc_assert ((!CALL_P (insn) || CONST_OR_PURE_CALL_P (insn))
                  && !LABEL_P (insn));

      uid = INSN_UID (insn);

      if (uid >= df->insn_size)
        df_insn_table_realloc (df, uid);

      df_insn_modify (df, bb, insn);

      if (insn == last_insn)
        break;
    }
}


/* Emit PATTERN before INSN within BB.  */
rtx
df_pattern_emit_before (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
  rtx ret_insn;
  rtx prev_insn = PREV_INSN (insn);

  /* We should not be inserting before the start of the block.  */
  gcc_assert (insn != BB_HEAD (bb));
  ret_insn = emit_insn_before (pattern, insn);
  if (ret_insn == insn)
    return ret_insn;

  df_insns_modify (df, bb, NEXT_INSN (prev_insn), ret_insn);
  return ret_insn;
}


/* Emit PATTERN after INSN within BB.  */
rtx
df_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
  rtx ret_insn;

  ret_insn = emit_insn_after (pattern, insn);
  if (ret_insn == insn)
    return ret_insn;

  df_insns_modify (df, bb, NEXT_INSN (insn), ret_insn);
  return ret_insn;
}


/* Emit jump PATTERN after INSN within BB.  */
rtx
df_jump_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
  rtx ret_insn;

  ret_insn = emit_jump_insn_after (pattern, insn);
  if (ret_insn == insn)
    return ret_insn;

  df_insns_modify (df, bb, NEXT_INSN (insn), ret_insn);
  return ret_insn;
}


/* Move INSN within BB before BEFORE_INSN within BEFORE_BB.

   This function should only be used to move loop invariant insns
   out of a loop where it has been proven that the def-use info
   will still be valid.  */
rtx
df_insn_move_before (struct df *df, basic_block bb, rtx insn, basic_block before_bb, rtx before_insn)
{
  struct df_link *link;
  unsigned int uid;

  if (! bb)
    return df_pattern_emit_before (df, insn, before_bb, before_insn);

  uid = INSN_UID (insn);

  /* Change bb for all df defined and used by this insn.  */
  for (link = df->insns[uid].defs; link; link = link->next)
    DF_REF_BB (link->ref) = before_bb;
  for (link = df->insns[uid].uses; link; link = link->next)
    DF_REF_BB (link->ref) = before_bb;

  /* The lifetimes of the registers used in this insn will be reduced
     while the lifetimes of the registers defined in this insn
     are likely to be increased.  */

  /* ???? Perhaps all the insns moved should be stored on a list
     which df_analyze removes when it recalculates data flow.  */

  return emit_insn_before (insn, before_insn);
}
\f
/* Functions to query dataflow information.  */


int
df_insn_regno_def_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
                     rtx insn, unsigned int regno)
{
  unsigned int uid;
  struct df_link *link;

  uid = INSN_UID (insn);

  for (link = df->insns[uid].defs; link; link = link->next)
    {
      struct ref *def = link->ref;

      if (DF_REF_REGNO (def) == regno)
        return 1;
    }

  return 0;
}

/* Finds the reference corresponding to the definition of REG in INSN.
   DF is the dataflow object.  */

struct ref *
df_find_def (struct df *df, rtx insn, rtx reg)
{
  struct df_link *defs;

  for (defs = DF_INSN_DEFS (df, insn); defs; defs = defs->next)
    if (rtx_equal_p (DF_REF_REG (defs->ref), reg))
      return defs->ref;

  return NULL;
}

/* Return 1 if REG is referenced in INSN, zero otherwise.  */ 

int
df_reg_used (struct df *df, rtx insn, rtx reg)
{
  struct df_link *uses;

  for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
    if (rtx_equal_p (DF_REF_REG (uses->ref), reg))
      return 1; 

  return 0;
}

static int
df_def_dominates_all_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
  struct df_link *du_link;

  /* Follow def-use chain to find all the uses of this def.  */
  for (du_link = DF_REF_CHAIN (def); du_link; du_link = du_link->next)
    {
      struct ref *use = du_link->ref;
      struct df_link *ud_link;

      /* Follow use-def chain to check all the defs for this use.  */
      for (ud_link = DF_REF_CHAIN (use); ud_link; ud_link = ud_link->next)
        if (ud_link->ref != def)
          return 0;
    }
  return 1;
}


int
df_insn_dominates_all_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
                              rtx insn)
{
  unsigned int uid;
  struct df_link *link;

  uid = INSN_UID (insn);

  for (link = df->insns[uid].defs; link; link = link->next)
    {
      struct ref *def = link->ref;

      if (! df_def_dominates_all_uses_p (df, def))
        return 0;
    }

  return 1;
}


/* Return nonzero if all DF dominates all the uses within the bitmap
   BLOCKS.  */
static int
df_def_dominates_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def,
                         bitmap blocks)
{
  struct df_link *du_link;

  /* Follow def-use chain to find all the uses of this def.  */
  for (du_link = DF_REF_CHAIN (def); du_link; du_link = du_link->next)
    {
      struct ref *use = du_link->ref;
      struct df_link *ud_link;

      /* Only worry about the uses within BLOCKS.  For example,
      consider a register defined within a loop that is live at the
      loop exits.  */
      if (bitmap_bit_p (blocks, DF_REF_BBNO (use)))
        {
          /* Follow use-def chain to check all the defs for this use.  */
          for (ud_link = DF_REF_CHAIN (use); ud_link; ud_link = ud_link->next)
            if (ud_link->ref != def)
              return 0;
        }
    }
  return 1;
}


/* Return nonzero if all the defs of INSN within BB dominates
   all the corresponding uses.  */
int
df_insn_dominates_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
                          rtx insn, bitmap blocks)
{
  unsigned int uid;
  struct df_link *link;

  uid = INSN_UID (insn);

  for (link = df->insns[uid].defs; link; link = link->next)
    {
      struct ref *def = link->ref;

      /* Only consider the defs within BLOCKS.  */
      if (bitmap_bit_p (blocks, DF_REF_BBNO (def))
          && ! df_def_dominates_uses_p (df, def, blocks))
        return 0;
    }
  return 1;
}


/* Return the basic block that REG referenced in or NULL if referenced
   in multiple basic blocks.  */
basic_block
df_regno_bb (struct df *df, unsigned int regno)
{
  struct df_link *defs = df->regs[regno].defs;
  struct df_link *uses = df->regs[regno].uses;
  struct ref *def = defs ? defs->ref : 0;
  struct ref *use = uses ? uses->ref : 0;
  basic_block bb_def = def ? DF_REF_BB (def) : 0;
  basic_block bb_use = use ? DF_REF_BB (use) : 0;

  /* Compare blocks of first def and last use.  ???? FIXME.  What if
     the reg-def and reg-use lists are not correctly ordered.  */
  return bb_def == bb_use ? bb_def : 0;
}


/* Return nonzero if REG used in multiple basic blocks.  */
int
df_reg_global_p (struct df *df, rtx reg)
{
  return df_regno_bb (df, REGNO (reg)) != 0;
}


/* Return total lifetime (in insns) of REG.  */
int
df_reg_lifetime (struct df *df, rtx reg)
{
  return df->regs[REGNO (reg)].lifetime;
}


/* Return nonzero if REG live at start of BB.  */
int
df_bb_reg_live_start_p (struct df *df, basic_block bb, rtx reg)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);

  gcc_assert (bb_info->lr_in);

  return bitmap_bit_p (bb_info->lr_in, REGNO (reg));
}


/* Return nonzero if REG live at end of BB.  */
int
df_bb_reg_live_end_p (struct df *df, basic_block bb, rtx reg)
{
  struct bb_info *bb_info = DF_BB_INFO (df, bb);

  gcc_assert (bb_info->lr_in);

  return bitmap_bit_p (bb_info->lr_out, REGNO (reg));
}


/* Return -1 if life of REG1 before life of REG2, 1 if life of REG1
   after life of REG2, or 0, if the lives overlap.  */
int
df_bb_regs_lives_compare (struct df *df, basic_block bb, rtx reg1, rtx reg2)
{
  unsigned int regno1 = REGNO (reg1);
  unsigned int regno2 = REGNO (reg2);
  struct ref *def1;
  struct ref *use1;
  struct ref *def2;
  struct ref *use2;


  /* The regs must be local to BB.  */
  gcc_assert (df_regno_bb (df, regno1) == bb
              && df_regno_bb (df, regno2) == bb);

  def2 = df_bb_regno_first_def_find (df, bb, regno2);
  use1 = df_bb_regno_last_use_find (df, bb, regno1);

  if (DF_INSN_LUID (df, DF_REF_INSN (def2))
      > DF_INSN_LUID (df, DF_REF_INSN (use1)))
    return -1;

  def1 = df_bb_regno_first_def_find (df, bb, regno1);
  use2 = df_bb_regno_last_use_find (df, bb, regno2);

  if (DF_INSN_LUID (df, DF_REF_INSN (def1))
      > DF_INSN_LUID (df, DF_REF_INSN (use2)))
    return 1;

  return 0;
}


/* Return last use of REGNO within BB.  */
struct ref *
df_bb_regno_last_use_find (struct df *df, basic_block bb, unsigned int regno)
{
  struct df_link *link;

  /* This assumes that the reg-use list is ordered such that for any
     BB, the last use is found first.  However, since the BBs are not
     ordered, the first use in the chain is not necessarily the last
     use in the function.  */
  for (link = df->regs[regno].uses; link; link = link->next)
    {
      struct ref *use = link->ref;

      if (DF_REF_BB (use) == bb)
        return use;
    }
  return 0;
}


/* Return first def of REGNO within BB.  */
struct ref *
df_bb_regno_first_def_find (struct df *df, basic_block bb, unsigned int regno)
{
  struct df_link *link;

  /* This assumes that the reg-def list is ordered such that for any
     BB, the first def is found first.  However, since the BBs are not
     ordered, the first def in the chain is not necessarily the first
     def in the function.  */
  for (link = df->regs[regno].defs; link; link = link->next)
    {
      struct ref *def = link->ref;

      if (DF_REF_BB (def) == bb)
        return def;
    }
  return 0;
}

/* Return last def of REGNO within BB.  */
struct ref *
df_bb_regno_last_def_find (struct df *df, basic_block bb, unsigned int regno)
{
  struct df_link *link;
  struct ref *last_def = NULL;
  int in_bb = 0;

  /* This assumes that the reg-def list is ordered such that for any
     BB, the first def is found first.  However, since the BBs are not
     ordered, the first def in the chain is not necessarily the first
     def in the function.  */
  for (link = df->regs[regno].defs; link; link = link->next)
    {
      struct ref *def = link->ref;
      /* The first time in the desired block.  */ 
      if (DF_REF_BB (def) == bb)
          in_bb = 1;
      /* The last def in the desired block.  */
      else if (in_bb)
        return last_def;
      last_def = def;
    }
  return last_def;
}

/* Return first use of REGNO inside INSN within BB.  */
static struct ref *
df_bb_insn_regno_last_use_find (struct df *df,
                                basic_block bb ATTRIBUTE_UNUSED, rtx insn,
                                unsigned int regno)
{
  unsigned int uid;
  struct df_link *link;

  uid = INSN_UID (insn);

  for (link = df->insns[uid].uses; link; link = link->next)
    {
      struct ref *use = link->ref;

      if (DF_REF_REGNO (use) == regno)
        return use;
    }

  return 0;
}


/* Return first def of REGNO inside INSN within BB.  */
static struct ref *
df_bb_insn_regno_first_def_find (struct df *df,
                                 basic_block bb ATTRIBUTE_UNUSED, rtx insn,
                                 unsigned int regno)
{
  unsigned int uid;
  struct df_link *link;

  uid = INSN_UID (insn);

  for (link = df->insns[uid].defs; link; link = link->next)
    {
      struct ref *def = link->ref;

      if (DF_REF_REGNO (def) == regno)
        return def;
    }

  return 0;
}


/* Return insn using REG if the BB contains only a single
   use and def of REG.  */
rtx
df_bb_single_def_use_insn_find (struct df *df, basic_block bb, rtx insn, rtx reg)
{
  struct ref *def;
  struct ref *use;
  struct df_link *du_link;

  def = df_bb_insn_regno_first_def_find (df, bb, insn, REGNO (reg));

  gcc_assert (def);

  du_link = DF_REF_CHAIN (def);

  if (! du_link)
    return NULL_RTX;

  use = du_link->ref;

  /* Check if def is dead.  */
  if (! use)
    return NULL_RTX;

  /* Check for multiple uses.  */
  if (du_link->next)
    return NULL_RTX;

  return DF_REF_INSN (use);
}
\f
/* Functions for debugging/dumping dataflow information.  */


/* Dump a def-use or use-def chain for REF to FILE.  */
static void
df_chain_dump (struct df_link *link, FILE *file)
{
  fprintf (file, "{ ");
  for (; link; link = link->next)
    {
      fprintf (file, "%c%d ",
               DF_REF_REG_DEF_P (link->ref) ? 'd' : 'u',
               DF_REF_ID (link->ref));
    }
  fprintf (file, "}");
}


/* Dump a chain of refs with the associated regno.  */
static void
df_chain_dump_regno (struct df_link *link, FILE *file)
{
  fprintf (file, "{ ");
  for (; link; link = link->next)
    {
      fprintf (file, "%c%d(%d) ",
               DF_REF_REG_DEF_P (link->ref) ? 'd' : 'u',
               DF_REF_ID (link->ref),
               DF_REF_REGNO (link->ref));
    }
  fprintf (file, "}");
}


/* Dump dataflow info.  */
void
df_dump (struct df *df, int flags, FILE *file)
{
  unsigned int j;
  basic_block bb;

  if (! df || ! file)
    return;

  fprintf (file, "\nDataflow summary:\n");
  fprintf (file, "n_regs = %d, n_defs = %d, n_uses = %d, n_bbs = %d\n",
           df->n_regs, df->n_defs, df->n_uses, df->n_bbs);

  if (flags & DF_RD)
    {
      basic_block bb;

      fprintf (file, "Reaching defs:\n");
      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);

          if (! bb_info->rd_in)
            continue;

          fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->rd_in);
          fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->rd_gen);
          fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->rd_kill);
          fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->rd_out);
        }
    }

  if (flags & DF_UD_CHAIN)
    {
      fprintf (file, "Use-def chains:\n");
      for (j = 0; j < df->n_defs; j++)
        {
          if (df->defs[j])
            {
              fprintf (file, "d%d bb %d luid %d insn %d reg %d ",
                       j, DF_REF_BBNO (df->defs[j]),
                       DF_INSN_LUID (df, DF_REF_INSN (df->defs[j])),
                       DF_REF_INSN_UID (df->defs[j]),
                       DF_REF_REGNO (df->defs[j]));
              if (df->defs[j]->flags & DF_REF_READ_WRITE)
                fprintf (file, "read/write ");
              df_chain_dump (DF_REF_CHAIN (df->defs[j]), file);
              fprintf (file, "\n");
            }
        }
    }

  if (flags & DF_RU)
    {
      fprintf (file, "Reaching uses:\n");
      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);

          if (! bb_info->ru_in)
            continue;

          fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->ru_in);
          fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->ru_gen);
          fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->ru_kill);
          fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->ru_out);
        }
    }

  if (flags & DF_DU_CHAIN)
    {
      fprintf (file, "Def-use chains:\n");
      for (j = 0; j < df->n_uses; j++)
        {
          if (df->uses[j])
            {
              fprintf (file, "u%d bb %d luid %d insn %d reg %d ",
                       j, DF_REF_BBNO (df->uses[j]),
                       DF_INSN_LUID (df, DF_REF_INSN (df->uses[j])),
                       DF_REF_INSN_UID (df->uses[j]),
                       DF_REF_REGNO (df->uses[j]));
              if (df->uses[j]->flags & DF_REF_READ_WRITE)
                fprintf (file, "read/write ");
              df_chain_dump (DF_REF_CHAIN (df->uses[j]), file);
              fprintf (file, "\n");
            }
        }
    }

  if (flags & DF_LR)
    {
      fprintf (file, "Live regs:\n");
      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);

          if (! bb_info->lr_in)
            continue;

          fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->lr_in);
          fprintf (file, "bb %d use \t", bb->index);
          dump_bitmap (file, bb_info->lr_use);
          fprintf (file, "bb %d def \t", bb->index);
          dump_bitmap (file, bb_info->lr_def);
          fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->lr_out);
        }
    }

  if (flags & (DF_REG_INFO | DF_RD_CHAIN | DF_RU_CHAIN))
    {
      struct reg_info *reg_info = df->regs;

      fprintf (file, "Register info:\n");
      for (j = 0; j < df->n_regs; j++)
        {
          if (((flags & DF_REG_INFO)
               && (reg_info[j].n_uses || reg_info[j].n_defs))
              || ((flags & DF_RD_CHAIN) && reg_info[j].defs)
              || ((flags & DF_RU_CHAIN) && reg_info[j].uses))
            {
              fprintf (file, "reg %d", j);
              if ((flags & DF_RD_CHAIN) && (flags & DF_RU_CHAIN))
                {
                  basic_block bb = df_regno_bb (df, j);

                  if (bb)
                    fprintf (file, " bb %d", bb->index);
                  else
                    fprintf (file, " bb ?");
                }
              if (flags & DF_REG_INFO)
                {
                  fprintf (file, " life %d", reg_info[j].lifetime);
                }

              if ((flags & DF_REG_INFO) || (flags & DF_RD_CHAIN))
                {
                  fprintf (file, " defs ");
                  if (flags & DF_REG_INFO)
                    fprintf (file, "%d ", reg_info[j].n_defs);
                  if (flags & DF_RD_CHAIN)
                    df_chain_dump (reg_info[j].defs, file);
                }

              if ((flags & DF_REG_INFO) || (flags & DF_RU_CHAIN))
                {
                  fprintf (file, " uses ");
                  if (flags & DF_REG_INFO)
                    fprintf (file, "%d ", reg_info[j].n_uses);
                  if (flags & DF_RU_CHAIN)
                    df_chain_dump (reg_info[j].uses, file);
                }

              fprintf (file, "\n");
            }
        }
    }
  fprintf (file, "\n");
}


void
df_insn_debug (struct df *df, rtx insn, FILE *file)
{
  unsigned int uid;
  int bbi;

  uid = INSN_UID (insn);
  if (uid >= df->insn_size)
    return;

  if (df->insns[uid].defs)
    bbi = DF_REF_BBNO (df->insns[uid].defs->ref);
  else if (df->insns[uid].uses)
    bbi = DF_REF_BBNO (df->insns[uid].uses->ref);
  else
    bbi = -1;

  fprintf (file, "insn %d bb %d luid %d defs ",
           uid, bbi, DF_INSN_LUID (df, insn));
  df_chain_dump (df->insns[uid].defs, file);
  fprintf (file, " uses ");
  df_chain_dump (df->insns[uid].uses, file);
  fprintf (file, "\n");
}


void
df_insn_debug_regno (struct df *df, rtx insn, FILE *file)
{
  unsigned int uid;
  int bbi;

  uid = INSN_UID (insn);
  if (uid >= df->insn_size)
    return;

  if (df->insns[uid].defs)
    bbi = DF_REF_BBNO (df->insns[uid].defs->ref);
  else if (df->insns[uid].uses)
    bbi = DF_REF_BBNO (df->insns[uid].uses->ref);
  else
    bbi = -1;

  fprintf (file, "insn %d bb %d luid %d defs ",
           uid, bbi, DF_INSN_LUID (df, insn));
  df_chain_dump_regno (df->insns[uid].defs, file);
  fprintf (file, " uses ");
  df_chain_dump_regno (df->insns[uid].uses, file);
  fprintf (file, "\n");
}


static void
df_regno_debug (struct df *df, unsigned int regno, FILE *file)
{
  if (regno >= df->reg_size)
    return;

  fprintf (file, "reg %d life %d defs ",
           regno, df->regs[regno].lifetime);
  df_chain_dump (df->regs[regno].defs, file);
  fprintf (file, " uses ");
  df_chain_dump (df->regs[regno].uses, file);
  fprintf (file, "\n");
}


static void
df_ref_debug (struct df *df, struct ref *ref, FILE *file)
{
  fprintf (file, "%c%d ",
           DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
           DF_REF_ID (ref));
  fprintf (file, "reg %d bb %d luid %d insn %d chain ",
           DF_REF_REGNO (ref),
           DF_REF_BBNO (ref),
           DF_INSN_LUID (df, DF_REF_INSN (ref)),
           INSN_UID (DF_REF_INSN (ref)));
  df_chain_dump (DF_REF_CHAIN (ref), file);
  fprintf (file, "\n");
}
\f
/* Functions for debugging from GDB.  */

void
debug_df_insn (rtx insn)
{
  df_insn_debug (ddf, insn, stderr);
  debug_rtx (insn);
}


void
debug_df_reg (rtx reg)
{
  df_regno_debug (ddf, REGNO (reg), stderr);
}


void
debug_df_regno (unsigned int regno)
{
  df_regno_debug (ddf, regno, stderr);
}


void
debug_df_ref (struct ref *ref)
{
  df_ref_debug (ddf, ref, stderr);
}


void
debug_df_defno (unsigned int defno)
{
  df_ref_debug (ddf, ddf->defs[defno], stderr);
}


void
debug_df_useno (unsigned int defno)
{
  df_ref_debug (ddf, ddf->uses[defno], stderr);
}


void
debug_df_chain (struct df_link *link)
{
  df_chain_dump (link, stderr);
  fputc ('\n', stderr);
}
\f

/* Perform the set operation OP1 OP OP2, using set representation REPR, and
   storing the result in OP1.  */

static void
dataflow_set_a_op_b (enum set_representation repr,
                     enum df_confluence_op op,
                     void *op1, void *op2)
{
  switch (repr)
    {
    case SR_SBITMAP:
      switch (op)
        {
        case DF_UNION:
          sbitmap_a_or_b (op1, op1, op2);
          break;

        case DF_INTERSECTION:
          sbitmap_a_and_b (op1, op1, op2);
          break;

        default:
          gcc_unreachable ();
        }
      break;

    case SR_BITMAP:
      switch (op)
        {
        case DF_UNION:
          bitmap_ior_into (op1, op2);
          break;

        case DF_INTERSECTION:
          bitmap_and_into (op1, op2);
          break;

        default:
          gcc_unreachable ();
        }
      break;

    default:
      gcc_unreachable ();
    }
}

static void
dataflow_set_copy (enum set_representation repr, void *dest, void *src)
{
  switch (repr)
    {
    case SR_SBITMAP:
      sbitmap_copy (dest, src);
      break;

    case SR_BITMAP:
      bitmap_copy (dest, src);
      break;

    default:
      gcc_unreachable ();
    }
}

/* Hybrid search algorithm from "Implementation Techniques for
   Efficient Data-Flow Analysis of Large Programs".  */

static void
hybrid_search (basic_block bb, struct dataflow *dataflow,
               sbitmap visited, sbitmap pending, sbitmap considered)
{
  int changed;
  int i = bb->index;
  edge e;
  edge_iterator ei;

  SET_BIT (visited, bb->index);
  gcc_assert (TEST_BIT (pending, bb->index));
  RESET_BIT (pending, i);

#define HS(E_ANTI, E_ANTI_BB, E_ANTI_START_BB, IN_SET,                  \
           E, E_BB, E_START_BB, OUT_SET)                                \
  do                                                                    \
    {                                                                   \
      /*  Calculate <conf_op> of predecessor_outs.  */                  \
      bitmap_zero (IN_SET[i]);                                          \
      FOR_EACH_EDGE (e, ei, bb->E_ANTI)                                 \
        {                                                               \
          if (e->E_ANTI_BB == E_ANTI_START_BB)                          \
            continue;                                                   \
          if (!TEST_BIT (considered, e->E_ANTI_BB->index))              \
            continue;                                                   \
                                                                        \
          dataflow_set_a_op_b (dataflow->repr, dataflow->conf_op,       \
                               IN_SET[i],                               \
                               OUT_SET[e->E_ANTI_BB->index]);           \
        }                                                               \
                                                                        \
      (*dataflow->transfun)(i, &changed,                                \
                            dataflow->in[i], dataflow->out[i],          \
                            dataflow->gen[i], dataflow->kill[i],        \
                            dataflow->data);                            \
                                                                        \
      if (!changed)                                                     \
        break;                                                          \
                                                                        \
      FOR_EACH_EDGE (e, ei, bb->E)                                              \
        {                                                               \
          if (e->E_BB == E_START_BB || e->E_BB->index == i)             \
            continue;                                                   \
                                                                        \
          if (!TEST_BIT (considered, e->E_BB->index))                   \
            continue;                                                   \
                                                                        \
          SET_BIT (pending, e->E_BB->index);                            \
        }                                                               \
                                                                        \
      FOR_EACH_EDGE (e, ei, bb->E)                                              \
        {                                                               \
          if (e->E_BB == E_START_BB || e->E_BB->index == i)             \
            continue;                                                   \
                                                                        \
          if (!TEST_BIT (considered, e->E_BB->index))                   \
            continue;                                                   \
                                                                        \
          if (!TEST_BIT (visited, e->E_BB->index))                      \
            hybrid_search (e->E_BB, dataflow, visited, pending, considered); \
        }                                                               \
    } while (0)

  if (dataflow->dir == DF_FORWARD)
    HS (preds, src, ENTRY_BLOCK_PTR, dataflow->in,
        succs, dest, EXIT_BLOCK_PTR, dataflow->out);
  else
    HS (succs, dest, EXIT_BLOCK_PTR, dataflow->out,
        preds, src, ENTRY_BLOCK_PTR, dataflow->in);
}

/* This function will perform iterative bitvector dataflow described by
   DATAFLOW, producing the in and out sets.  Only the part of the cfg
   induced by blocks in DATAFLOW->order is taken into account.

   For forward problems, you probably want to pass in a mapping of
   block number to rc_order (like df->inverse_rc_map).  */

void
iterative_dataflow (struct dataflow *dataflow)
{
  unsigned i, idx;
  sbitmap visited, pending, considered;

  pending = sbitmap_alloc (last_basic_block);
  visited = sbitmap_alloc (last_basic_block);
  considered = sbitmap_alloc (last_basic_block);
  sbitmap_zero (pending);
  sbitmap_zero (visited);
  sbitmap_zero (considered);

  for (i = 0; i < dataflow->n_blocks; i++)
    {
      idx = dataflow->order[i];
      SET_BIT (pending, idx);
      SET_BIT (considered, idx);
      if (dataflow->dir == DF_FORWARD)
        dataflow_set_copy (dataflow->repr,
                           dataflow->out[idx], dataflow->gen[idx]);
      else
        dataflow_set_copy (dataflow->repr,
                           dataflow->in[idx], dataflow->gen[idx]);
    };

  while (1)
    {
      for (i = 0; i < dataflow->n_blocks; i++)
        {
          idx = dataflow->order[i];

          if (TEST_BIT (pending, idx) && !TEST_BIT (visited, idx))
            hybrid_search (BASIC_BLOCK (idx), dataflow,
                           visited, pending, considered);
        }

      if (sbitmap_first_set_bit (pending) == -1)
        break;

      sbitmap_zero (visited);
    }

  sbitmap_free (pending);
  sbitmap_free (visited);
  sbitmap_free (considered);
}