4) Working with a sub-CFG.
Often the whole CFG does not need to be analyzed, for example,
-when optimising a loop, only certain registers are of interest.
+when optimizing a loop, only certain registers are of interest.
Perhaps there should be a bitmap argument to df_analyse to specify
which registers should be analyzed?
#include "recog.h"
#include "function.h"
#include "regs.h"
-#include "obstack.h"
+#include "alloc-pool.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "sbitmap.h"
} \
while (0)
-static struct obstack df_ref_obstack;
+static alloc_pool df_ref_pool;
+static alloc_pool df_link_pool;
static struct df *ddf;
-static void df_reg_table_realloc PARAMS((struct df *, int));
-static void df_insn_table_realloc PARAMS((struct df *, unsigned int));
-static void df_bitmaps_alloc PARAMS((struct df *, int));
-static void df_bitmaps_free PARAMS((struct df *, int));
-static void df_free PARAMS((struct df *));
-static void df_alloc PARAMS((struct df *, int));
-
-static rtx df_reg_clobber_gen PARAMS((unsigned int));
-static rtx df_reg_use_gen PARAMS((unsigned int));
-
-static inline struct df_link *df_link_create PARAMS((struct ref *,
- struct df_link *));
-static struct df_link *df_ref_unlink PARAMS((struct df_link **, struct ref *));
-static void df_def_unlink PARAMS((struct df *, struct ref *));
-static void df_use_unlink PARAMS((struct df *, struct ref *));
-static void df_insn_refs_unlink PARAMS ((struct df *, basic_block, rtx));
+static void df_reg_table_realloc (struct df *, int);
+static void df_insn_table_realloc (struct df *, unsigned int);
+static void df_bitmaps_alloc (struct df *, 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_clobber_gen (unsigned 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 PARAMS ((struct df *, basic_block));
-static void df_refs_unlink PARAMS ((struct df *, bitmap));
+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 PARAMS((struct df *,
- rtx, rtx *, rtx,
- enum df_ref_type, enum df_ref_flags));
-static void df_ref_record_1 PARAMS((struct df *, rtx, rtx *,
- rtx, enum df_ref_type,
- enum df_ref_flags));
-static void df_ref_record PARAMS((struct df *, rtx, rtx *,
- rtx, enum df_ref_type,
- enum df_ref_flags));
-static void df_def_record_1 PARAMS((struct df *, rtx, basic_block, rtx));
-static void df_defs_record PARAMS((struct df *, rtx, basic_block, rtx));
-static void df_uses_record PARAMS((struct df *, rtx *,
- enum df_ref_type, basic_block, rtx,
- enum df_ref_flags));
-static void df_insn_refs_record PARAMS((struct df *, basic_block, rtx));
-static void df_bb_refs_record PARAMS((struct df *, basic_block));
-static void df_refs_record PARAMS((struct df *, bitmap));
-
-static void df_bb_reg_def_chain_create PARAMS((struct df *, basic_block));
-static void df_reg_def_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_reg_use_chain_create PARAMS((struct df *, basic_block));
-static void df_reg_use_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_du_chain_create PARAMS((struct df *, basic_block, bitmap));
-static void df_du_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_ud_chain_create PARAMS((struct df *, basic_block));
-static void df_ud_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_rd_local_compute PARAMS((struct df *, basic_block));
-static void df_rd_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_ru_local_compute PARAMS((struct df *, basic_block));
-static void df_ru_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_lr_local_compute PARAMS((struct df *, basic_block));
-static void df_lr_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_reg_info_compute PARAMS((struct df *, basic_block, bitmap));
-static void df_reg_info_compute PARAMS((struct df *, bitmap));
-
-static int df_bb_luids_set PARAMS((struct df *df, basic_block));
-static int df_luids_set PARAMS((struct df *df, bitmap));
-
-static int df_modified_p PARAMS ((struct df *, bitmap));
-static int df_refs_queue PARAMS ((struct df *));
-static int df_refs_process PARAMS ((struct df *));
-static int df_bb_refs_update PARAMS ((struct df *, basic_block));
-static int df_refs_update PARAMS ((struct df *));
-static void df_analyse_1 PARAMS((struct df *, bitmap, int, int));
-
-static void df_insns_modify PARAMS((struct df *, basic_block,
- rtx, rtx));
-static int df_rtx_mem_replace PARAMS ((rtx *, void *));
-static int df_rtx_reg_replace PARAMS ((rtx *, void *));
-void df_refs_reg_replace PARAMS ((struct df *, bitmap,
- struct df_link *, rtx, rtx));
-
-static int df_def_dominates_all_uses_p PARAMS((struct df *, struct ref *def));
-static int df_def_dominates_uses_p PARAMS((struct df *,
- struct ref *def, bitmap));
-static struct ref *df_bb_regno_last_use_find PARAMS((struct df *, basic_block,
- unsigned int));
-static struct ref *df_bb_regno_first_def_find PARAMS((struct df *, basic_block,
- unsigned int));
-static struct ref *df_bb_insn_regno_last_use_find PARAMS((struct df *,
- basic_block,
- rtx, unsigned int));
-static struct ref *df_bb_insn_regno_first_def_find PARAMS((struct df *,
- basic_block,
- rtx, unsigned int));
-
-static void df_chain_dump PARAMS((struct df_link *, FILE *file));
-static void df_chain_dump_regno PARAMS((struct df_link *, FILE *file));
-static void df_regno_debug PARAMS ((struct df *, unsigned int, FILE *));
-static void df_ref_debug PARAMS ((struct df *, struct ref *, FILE *));
-static void df_rd_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void df_ru_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void df_lr_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void hybrid_search_bitmap PARAMS ((basic_block, bitmap *, bitmap *,
- bitmap *, bitmap *, enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_bitmap,
- sbitmap, sbitmap, void *));
-static void hybrid_search_sbitmap PARAMS ((basic_block, sbitmap *, sbitmap *,
- sbitmap *, sbitmap *, enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_sbitmap,
- sbitmap, sbitmap, void *));
-static inline bool read_modify_subreg_p PARAMS ((rtx));
+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);
+static void df_bb_reg_use_chain_create (struct df *, basic_block);
+static void df_reg_use_chain_create (struct df *, bitmap);
+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);
+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 *);
+static void df_analyse_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_regno_last_use_find (struct df *, basic_block,
+ unsigned int);
+static struct ref *df_bb_regno_first_def_find (struct df *, basic_block,
+ unsigned int);
+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 *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void df_ru_transfer_function (int, int *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void df_lr_transfer_function (int, int *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void hybrid_search_bitmap (basic_block, bitmap *, bitmap *,
+ bitmap *, bitmap *, enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_bitmap,
+ sbitmap, sbitmap, void *);
+static void hybrid_search_sbitmap (basic_block, sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *, enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_sbitmap,
+ sbitmap, sbitmap, void *);
\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 (df, size)
- struct df *df;
- unsigned int size;
+df_insn_table_realloc (struct df *df, unsigned int size)
{
size++;
if (size <= df->insn_size)
to enlarge it so often. */
size += df->insn_size / 4;
- df->insns = (struct insn_info *)
- xrealloc (df->insns, size * sizeof (struct insn_info));
+ 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));
/* Increase the reg info table by SIZE more elements. */
static void
-df_reg_table_realloc (df, size)
- struct df *df;
- int size;
+df_reg_table_realloc (struct df *df, int size)
{
/* Make table 25 percent larger by default. */
if (! size)
if (size < max_reg_num ())
size = max_reg_num ();
- df->regs = (struct reg_info *)
- xrealloc (df->regs, size * sizeof (struct reg_info));
+ df->regs = xrealloc (df->regs, size * sizeof (struct reg_info));
/* Zero the new entries. */
memset (df->regs + df->reg_size, 0,
/* Allocate bitmaps for each basic block. */
static void
-df_bitmaps_alloc (df, flags)
- struct df *df;
- int flags;
+df_bitmaps_alloc (struct df *df, int flags)
{
int dflags = 0;
basic_block bb;
/* Free bitmaps for each basic block. */
static void
-df_bitmaps_free (df, flags)
- struct df *df ATTRIBUTE_UNUSED;
- int flags;
+df_bitmaps_free (struct df *df, int flags)
{
basic_block bb;
/* Allocate and initialize dataflow memory. */
static void
-df_alloc (df, n_regs)
- struct df *df;
- int n_regs;
+df_alloc (struct df *df, int n_regs)
{
int n_insns;
basic_block bb;
- gcc_obstack_init (&df_ref_obstack);
+ 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. */
/* Free all the dataflow info. */
static void
-df_free (df)
- struct df *df;
+df_free (struct df *df)
{
df_bitmaps_free (df, DF_ALL);
BITMAP_XFREE (df->all_blocks);
df->all_blocks = 0;
- obstack_free (&df_ref_obstack, NULL);
+ 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 (regno)
- unsigned int regno;
+static rtx df_reg_use_gen (unsigned int regno)
{
rtx reg;
rtx use;
/* Return a CLOBBER for register REGNO. */
-static rtx df_reg_clobber_gen (regno)
- unsigned int regno;
+static rtx df_reg_clobber_gen (unsigned int regno)
{
rtx reg;
rtx use;
/* Create a link in a def-use or use-def chain. */
static inline struct df_link *
-df_link_create (ref, next)
- struct ref *ref;
- struct df_link *next;
+df_link_create (struct ref *ref, struct df_link *next)
{
struct df_link *link;
- link = (struct df_link *) obstack_alloc (&df_ref_obstack,
- sizeof (*link));
+ link = pool_alloc (df_link_pool);
link->next = next;
link->ref = ref;
return link;
/* Add REF to chain head pointed to by PHEAD. */
static struct df_link *
-df_ref_unlink (phead, ref)
- struct df_link **phead;
- struct ref *ref;
+df_ref_unlink (struct df_link **phead, struct ref *ref)
{
struct df_link *link = *phead;
/* Unlink REF from all def-use/use-def chains, etc. */
int
-df_ref_remove (df, ref)
- struct df *df;
- struct ref *ref;
+df_ref_remove (struct df *df, struct ref *ref)
{
if (DF_REF_REG_DEF_P (ref))
{
/* Unlink DEF from use-def and reg-def chains. */
static void
-df_def_unlink (df, def)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
+df_def_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
struct df_link *du_link;
unsigned int dregno = DF_REF_REGNO (def);
/* Unlink use from def-use and reg-use chains. */
static void
-df_use_unlink (df, use)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *use;
+df_use_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *use)
{
struct df_link *ud_link;
unsigned int uregno = DF_REF_REGNO (use);
/* 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 (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+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 = (struct ref *) obstack_alloc (&df_ref_obstack,
- sizeof (*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;
/* 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 (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+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 (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+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;
{
loc = &SUBREG_REG (reg);
reg = *loc;
+ ref_flags |= DF_REF_STRIPPED;
}
regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
}
-/* Return non-zero if writes to paradoxical SUBREGs, or SUBREGs which
+/* Return nonzero if writes to paradoxical SUBREGs, or SUBREGs which
are too narrow, are read-modify-write. */
-static inline bool
-read_modify_subreg_p (x)
- rtx x;
+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));
- if (isize <= osize)
- return true;
- if (isize <= UNITS_PER_WORD)
- return false;
- if (osize > UNITS_PER_WORD)
- return false;
- return true;
+ /* Paradoxical subreg writes don't leave a trace of the old content. */
+ return (isize > osize && isize > UNITS_PER_WORD);
}
/* Process all the registers defined in the rtx, X. */
static void
-df_def_record_1 (df, x, bb, insn)
- struct df *df;
- rtx x;
- basic_block bb;
- rtx insn;
-{
- rtx *loc = &SET_DEST (x);
- rtx dst = *loc;
+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--)
- df_def_record_1 (df, XVECEXP (dst, 0, i), bb, insn);
+ {
+ 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;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (GET_CODE (dst) == SUBREG
- && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
-
/* 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
|| GET_CODE (dst) == SIGN_EXTRACT
- || read_modify_subreg_p (dst))
+ || ((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. */
loc = &XEXP (dst, 0);
dst = *loc;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (GET_CODE (dst) == SUBREG
- && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
loc = &XEXP (dst, 0);
dst = *loc;
flags |= DF_REF_READ_WRITE;
/* Process all the registers defined in the pattern rtx, X. */
static void
-df_defs_record (df, x, bb, insn)
- struct df *df;
- rtx x;
- basic_block bb;
- rtx insn;
+df_defs_record (struct df *df, rtx x, basic_block bb, rtx insn)
{
RTX_CODE code = GET_CODE (x);
/* Process all the registers used in the rtx at address LOC. */
static void
-df_uses_record (df, loc, ref_type, bb, insn, flags)
- struct df *df;
- rtx *loc;
- enum df_ref_type ref_type;
- basic_block bb;
- rtx insn;
- enum df_ref_flags flags;
+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;
df_uses_record (df, loc, ref_type, bb, insn, flags);
return;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (x),
- GET_MODE (SUBREG_REG (x))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
-
/* ... Fall through ... */
case REG:
{
enum df_ref_flags use_flags;
case SUBREG:
- if (read_modify_subreg_p (dst))
+ if ((df->flags & DF_FOR_REGALLOC) == 0
+ && read_modify_subreg_p (dst))
{
use_flags = DF_REF_READ_WRITE;
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- use_flags |= DF_REF_MODE_CHANGE;
-#endif
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, use_flags);
break;
if (GET_CODE (dst) != SUBREG)
abort ();
use_flags = DF_REF_READ_WRITE;
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- use_flags |= DF_REF_MODE_CHANGE;
-#endif
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, use_flags);
break;
/* Record all the df within INSN of basic block BB. */
static void
-df_insn_refs_record (df, bb, insn)
- struct df *df;
- basic_block bb;
- rtx insn;
+df_insn_refs_record (struct df *df, basic_block bb, rtx insn)
{
int i;
{
rtx note;
- /* Record register defs */
+ /* Record register defs. */
df_defs_record (df, PATTERN (insn), bb, insn);
if (df->flags & DF_EQUIV_NOTES)
/* Record all the refs within the basic block BB. */
static void
-df_bb_refs_record (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_record (struct df *df, basic_block bb)
{
rtx insn;
/* Record all the refs in the basic blocks specified by BLOCKS. */
static void
-df_refs_record (df, blocks)
- struct df *df;
- bitmap blocks;
+df_refs_record (struct df *df, bitmap blocks)
{
basic_block bb;
/* 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 (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_reg_def_chain_create (struct df *df, basic_block bb)
{
rtx insn;
/* Create reg-def chains for each basic block within BLOCKS. These
are a list of definitions for each register. */
static void
-df_reg_def_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_def_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
/* 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 (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_reg_use_chain_create (struct df *df, basic_block bb)
{
rtx insn;
/* Create reg-use chains for each basic block within BLOCKS. These
are a list of uses for each register. */
static void
-df_reg_use_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_use_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
/* Create def-use chains from reaching use bitmaps for basic block BB. */
static void
-df_bb_du_chain_create (df, bb, ru)
- struct df *df;
- basic_block bb;
- bitmap ru;
+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;
/* Create def-use chains from reaching use bitmaps for basic blocks
in BLOCKS. */
static void
-df_du_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_du_chain_create (struct df *df, bitmap blocks)
{
bitmap ru;
basic_block bb;
/* Create use-def chains from reaching def bitmaps for basic block BB. */
static void
-df_bb_ud_chain_create (df, bb)
- struct df *df;
- basic_block bb;
+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;
/* Create use-def chains from reaching def bitmaps for basic blocks
within BLOCKS. */
static void
-df_ud_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_ud_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
static void
-df_rd_transfer_function (bb, changed, in, out, gen, kill, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, gen, kill;
- void *data ATTRIBUTE_UNUSED;
+df_rd_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap gen, bitmap kill,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (out, gen, in, kill);
}
static void
-df_ru_transfer_function (bb, changed, in, out, gen, kill, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, gen, kill;
- void *data ATTRIBUTE_UNUSED;
+df_ru_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap gen, bitmap kill,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (in, gen, out, kill);
}
static void
-df_lr_transfer_function (bb, changed, in, out, use, def, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, use, def;
- void *data ATTRIBUTE_UNUSED;
+df_lr_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap use, bitmap def,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (in, use, out, def);
}
/* Compute local reaching def info for basic block BB. */
static void
-df_bb_rd_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_rd_local_compute (struct df *df, basic_block bb)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn;
/* Compute local reaching def info for each basic block within BLOCKS. */
static void
-df_rd_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_rd_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute local reaching use (upward exposed use) info for basic
block BB. */
static void
-df_bb_ru_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+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
/* Compute local reaching use (upward exposed use) info for each basic
block within BLOCKS. */
static void
-df_ru_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_ru_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute local live variable info for basic block BB. */
static void
-df_bb_lr_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_lr_local_compute (struct df *df, basic_block bb)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn;
/* Compute local live variable info for each basic block within BLOCKS. */
static void
-df_lr_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_lr_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute register info: lifetime, bb, and number of defs and uses
for basic block BB. */
static void
-df_bb_reg_info_compute (df, bb, live)
- struct df *df;
- basic_block bb;
- bitmap live;
+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);
/* Compute register info: lifetime, bb, and number of defs and uses. */
static void
-df_reg_info_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_info_compute (struct df *df, bitmap blocks)
{
basic_block bb;
bitmap live;
/* Assign LUIDs for BB. */
static int
-df_bb_luids_set (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_luids_set (struct df *df, basic_block bb)
{
rtx insn;
int luid = 0;
/* Assign LUIDs for each basic block within BLOCKS. */
static int
-df_luids_set (df, blocks)
- struct df *df;
- bitmap blocks;
+df_luids_set (struct df *df, bitmap blocks)
{
basic_block bb;
int total = 0;
/* 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_analyse_1 (df, blocks, flags, update)
- struct df *df;
- bitmap blocks;
- int flags;
- int update;
+df_analyse_1 (struct df *df, bitmap blocks, int flags, int update)
{
int aflags;
int dflags;
{
df_reg_info_compute (df, df->all_blocks);
}
+
free (df->dfs_order);
free (df->rc_order);
free (df->rts_order);
/* Initialize dataflow analysis. */
struct df *
-df_init ()
+df_init (void)
{
struct df *df;
/* Start queuing refs. */
static int
-df_refs_queue (df)
- struct df *df;
+df_refs_queue (struct df *df)
{
df->def_id_save = df->def_id;
df->use_id_save = df->use_id;
/* Process queued refs. */
static int
-df_refs_process (df)
- struct df *df;
+df_refs_process (struct df *df)
{
unsigned int i;
/* Update refs for basic block BB. */
static int
-df_bb_refs_update (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_update (struct df *df, basic_block bb)
{
rtx insn;
int count = 0;
/* Process all the modified/deleted insns that were queued. */
static int
-df_refs_update (df)
- struct df *df;
+df_refs_update (struct df *df)
{
basic_block bb;
int count = 0;
/* Return nonzero if any of the requested blocks in the bitmap
BLOCKS have been modified. */
static int
-df_modified_p (df, blocks)
- struct df *df;
- bitmap blocks;
+df_modified_p (struct df *df, bitmap blocks)
{
int update = 0;
basic_block bb;
BLOCKS, or for the whole CFG if BLOCKS is zero, or just for the
modified blocks if BLOCKS is -1. */
int
-df_analyse (df, blocks, flags)
- struct df *df;
- bitmap blocks;
- int flags;
+df_analyse (struct df *df, bitmap blocks, int flags)
{
int update;
/* Free all the dataflow info and the DF structure. */
void
-df_finish (df)
- struct df *df;
+df_finish (struct df *df)
{
df_free (df);
free (df);
/* Unlink INSN from its reference information. */
static void
-df_insn_refs_unlink (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+df_insn_refs_unlink (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
{
struct df_link *link;
unsigned int uid;
#if 0
/* Unlink all the insns within BB from their reference information. */
static void
-df_bb_refs_unlink (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_unlink (struct df *df, basic_block bb)
{
rtx insn;
/* Unlink all the refs in the basic blocks specified by BLOCKS.
Not currently used. */
static void
-df_refs_unlink (df, blocks)
- struct df *df;
- bitmap blocks;
+df_refs_unlink (struct df *df, bitmap blocks)
{
basic_block bb;
/* Delete INSN and all its reference information. */
rtx
-df_insn_delete (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+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? */
harm calling this function if the insn wasn't changed; it will just
slow down the rescanning of refs. */
void
-df_insn_modify (df, bb, insn)
- struct df *df;
- basic_block bb;
- rtx insn;
+df_insn_modify (struct df *df, basic_block bb, rtx insn)
{
unsigned int uid;
instruction currently being scanned and the MEM we are currently
replacing. */
static int
-df_rtx_mem_replace (px, data)
- rtx *px;
- void *data;
+df_rtx_mem_replace (rtx *px, void *data)
{
replace_args *args = (replace_args *) data;
rtx mem = *px;
int
-df_insn_mem_replace (df, bb, insn, mem, reg)
- struct df *df;
- basic_block bb;
- rtx insn;
- rtx mem;
- rtx reg;
+df_insn_mem_replace (struct df *df, basic_block bb, rtx insn, rtx mem, rtx reg)
{
replace_args args;
points to the rtx being scanned. DATA is actually a pointer to a
structure of arguments. */
static int
-df_rtx_reg_replace (px, data)
- rtx *px;
- void *data;
+df_rtx_reg_replace (rtx *px, void *data)
{
rtx x = *px;
replace_args *args = (replace_args *) data;
BLOCKS of basic blocks with NEWREG. Also update the regs within
REG_NOTES. */
void
-df_refs_reg_replace (df, blocks, chain, oldreg, newreg)
- struct df *df;
- bitmap blocks;
- struct df_link *chain;
- rtx oldreg;
- rtx newreg;
+df_refs_reg_replace (struct df *df, bitmap blocks, struct df_link *chain, rtx oldreg, rtx newreg)
{
struct df_link *link;
replace_args args;
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 (df, blocks, oldreg, newreg)
- struct df *df;
- bitmap blocks;
- rtx oldreg;
- rtx newreg;
+df_reg_replace (struct df *df, bitmap blocks, rtx oldreg, rtx newreg)
{
unsigned int oldregno = REGNO (oldreg);
/* Try replacing the reg within REF with NEWREG. Do not modify
def-use/use-def chains. */
int
-df_ref_reg_replace (df, ref, oldreg, newreg)
- struct df *df;
- struct ref *ref;
- rtx oldreg;
- rtx newreg;
+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. */
struct ref*
-df_bb_def_use_swap (df, bb, def_insn, use_insn, regno)
- struct df * df;
- basic_block bb;
- rtx def_insn;
- rtx use_insn;
- unsigned int regno;
+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;
/* Record df between FIRST_INSN and LAST_INSN inclusive. All new
insns must be processed by this routine. */
static void
-df_insns_modify (df, bb, first_insn, last_insn)
- struct df *df;
- basic_block bb;
- rtx first_insn;
- rtx last_insn;
+df_insns_modify (struct df *df, basic_block bb, rtx first_insn, rtx last_insn)
{
rtx insn;
/* Emit PATTERN before INSN within BB. */
rtx
-df_pattern_emit_before (df, pattern, bb, insn)
- struct df *df ATTRIBUTE_UNUSED;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_pattern_emit_before (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
rtx prev_insn = PREV_INSN (insn);
/* Emit PATTERN after INSN within BB. */
rtx
-df_pattern_emit_after (df, pattern, bb, insn)
- struct df *df;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
/* Emit jump PATTERN after INSN within BB. */
rtx
-df_jump_pattern_emit_after (df, pattern, bb, insn)
- struct df *df;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_jump_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
out of a loop where it has been proven that the def-use info
will still be valid. */
rtx
-df_insn_move_before (df, bb, insn, before_bb, before_insn)
- struct df *df;
- basic_block bb;
- rtx insn;
- basic_block before_bb;
- rtx before_insn;
+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;
int
-df_insn_regno_def_p (df, bb, insn, regno)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+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;
static int
-df_def_dominates_all_uses_p (df, def)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
+df_def_dominates_all_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
struct df_link *du_link;
int
-df_insn_dominates_all_uses_p (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+df_insn_dominates_all_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
+ rtx insn)
{
unsigned int uid;
struct df_link *link;
/* Return nonzero if all DF dominates all the uses within the bitmap
BLOCKS. */
static int
-df_def_dominates_uses_p (df, def, blocks)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
- bitmap blocks;
+df_def_dominates_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def,
+ bitmap blocks)
{
struct df_link *du_link;
/* Return nonzero if all the defs of INSN within BB dominates
all the corresponding uses. */
int
-df_insn_dominates_uses_p (df, bb, insn, blocks)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- bitmap blocks;
+df_insn_dominates_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
+ rtx insn, bitmap blocks)
{
unsigned int uid;
struct df_link *link;
/* Return the basic block that REG referenced in or NULL if referenced
in multiple basic blocks. */
basic_block
-df_regno_bb (df, regno)
- struct df *df;
- unsigned int regno;
+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;
/* Return nonzero if REG used in multiple basic blocks. */
int
-df_reg_global_p (df, reg)
- struct df *df;
- rtx reg;
+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 (df, reg)
- struct df *df;
- rtx reg;
+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 (df, bb, reg)
- struct df *df ATTRIBUTE_UNUSED;
- basic_block bb;
- rtx reg;
+df_bb_reg_live_start_p (struct df *df, basic_block bb, rtx reg)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
/* Return nonzero if REG live at end of BB. */
int
-df_bb_reg_live_end_p (df, bb, reg)
- struct df *df ATTRIBUTE_UNUSED;
- basic_block bb;
- rtx reg;
+df_bb_reg_live_end_p (struct df *df, basic_block bb, rtx reg)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
/* 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 (df, bb, reg1, reg2)
- struct df *df;
- basic_block bb;
- rtx reg1;
- rtx reg2;
+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);
/* Return last use of REGNO within BB. */
static struct ref *
-df_bb_regno_last_use_find (df, bb, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- unsigned int regno;
+df_bb_regno_last_use_find (struct df *df, basic_block bb, unsigned int regno)
{
struct df_link *link;
/* Return first def of REGNO within BB. */
static struct ref *
-df_bb_regno_first_def_find (df, bb, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- unsigned int regno;
+df_bb_regno_first_def_find (struct df *df, basic_block bb, unsigned int regno)
{
struct df_link *link;
/* Return first use of REGNO inside INSN within BB. */
static struct ref *
-df_bb_insn_regno_last_use_find (df, bb, insn, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+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;
/* Return first def of REGNO inside INSN within BB. */
static struct ref *
-df_bb_insn_regno_first_def_find (df, bb, insn, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+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;
/* Return insn using REG if the BB contains only a single
use and def of REG. */
rtx
-df_bb_single_def_use_insn_find (df, bb, insn, reg)
- struct df * df;
- basic_block bb;
- rtx insn;
- rtx reg;
+df_bb_single_def_use_insn_find (struct df *df, basic_block bb, rtx insn, rtx reg)
{
struct ref *def;
struct ref *use;
/* Dump a def-use or use-def chain for REF to FILE. */
static void
-df_chain_dump (link, file)
- struct df_link *link;
- FILE *file;
+df_chain_dump (struct df_link *link, FILE *file)
{
fprintf (file, "{ ");
for (; link; link = link->next)
/* Dump a chain of refs with the associated regno. */
static void
-df_chain_dump_regno (link, file)
- struct df_link *link;
- FILE *file;
+df_chain_dump_regno (struct df_link *link, FILE *file)
{
fprintf (file, "{ ");
for (; link; link = link->next)
/* Dump dataflow info. */
void
-df_dump (df, flags, file)
- struct df *df;
- int flags;
- FILE *file;
+df_dump (struct df *df, int flags, FILE *file)
{
unsigned int j;
basic_block bb;
void
-df_insn_debug (df, insn, file)
- struct df *df;
- rtx insn;
- FILE *file;
+df_insn_debug (struct df *df, rtx insn, FILE *file)
{
unsigned int uid;
int bbi;
void
-df_insn_debug_regno (df, insn, file)
- struct df *df;
- rtx insn;
- FILE *file;
+df_insn_debug_regno (struct df *df, rtx insn, FILE *file)
{
unsigned int uid;
int bbi;
static void
-df_regno_debug (df, regno, file)
- struct df *df;
- unsigned int regno;
- FILE *file;
+df_regno_debug (struct df *df, unsigned int regno, FILE *file)
{
if (regno >= df->reg_size)
return;
static void
-df_ref_debug (df, ref, file)
- struct df *df;
- struct ref *ref;
- FILE *file;
+df_ref_debug (struct df *df, struct ref *ref, FILE *file)
{
fprintf (file, "%c%d ",
DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
/* Functions for debugging from GDB. */
void
-debug_df_insn (insn)
- rtx insn;
+debug_df_insn (rtx insn)
{
df_insn_debug (ddf, insn, stderr);
debug_rtx (insn);
void
-debug_df_reg (reg)
- rtx reg;
+debug_df_reg (rtx reg)
{
df_regno_debug (ddf, REGNO (reg), stderr);
}
void
-debug_df_regno (regno)
- unsigned int regno;
+debug_df_regno (unsigned int regno)
{
df_regno_debug (ddf, regno, stderr);
}
void
-debug_df_ref (ref)
- struct ref *ref;
+debug_df_ref (struct ref *ref)
{
df_ref_debug (ddf, ref, stderr);
}
void
-debug_df_defno (defno)
- unsigned int defno;
+debug_df_defno (unsigned int defno)
{
df_ref_debug (ddf, ddf->defs[defno], stderr);
}
void
-debug_df_useno (defno)
- unsigned int defno;
+debug_df_useno (unsigned int defno)
{
df_ref_debug (ddf, ddf->uses[defno], stderr);
}
void
-debug_df_chain (link)
- struct df_link *link;
+debug_df_chain (struct df_link *link)
{
df_chain_dump (link, stderr);
fputc ('\n', stderr);
/* Hybrid search algorithm from "Implementation Techniques for
Efficient Data-Flow Analysis of Large Programs". */
static void
-hybrid_search_bitmap (block, in, out, gen, kill, dir,
- conf_op, transfun, visited, pending,
- data)
- basic_block block;
- bitmap *in, *out, *gen, *kill;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_bitmap transfun;
- sbitmap visited;
- sbitmap pending;
- void *data;
+hybrid_search_bitmap (basic_block block, bitmap *in, bitmap *out, bitmap *gen,
+ bitmap *kill, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_bitmap transfun, sbitmap visited,
+ sbitmap pending, void *data)
{
int changed;
int i = block->index;
/* Hybrid search for sbitmaps, rather than bitmaps. */
static void
-hybrid_search_sbitmap (block, in, out, gen, kill, dir,
- conf_op, transfun, visited, pending,
- data)
- basic_block block;
- sbitmap *in, *out, *gen, *kill;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_sbitmap transfun;
- sbitmap visited;
- sbitmap pending;
- void *data;
+hybrid_search_sbitmap (basic_block block, sbitmap *in, sbitmap *out,
+ sbitmap *gen, sbitmap *kill, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_sbitmap transfun, sbitmap visited,
+ sbitmap pending, void *data)
{
int changed;
int i = block->index;
block number to rc_order (like df->inverse_rc_map).
*/
void
-iterative_dataflow_sbitmap (in, out, gen, kill, blocks,
- dir, conf_op, transfun, order, data)
- sbitmap *in, *out, *gen, *kill;
- bitmap blocks;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_sbitmap transfun;
- int *order;
- void *data;
+iterative_dataflow_sbitmap (sbitmap *in, sbitmap *out, sbitmap *gen,
+ sbitmap *kill, bitmap blocks,
+ enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_sbitmap transfun, int *order,
+ void *data)
{
int i;
fibheap_t worklist;
/* Exactly the same as iterative_dataflow_sbitmap, except it works on
bitmaps instead. */
void
-iterative_dataflow_bitmap (in, out, gen, kill, blocks,
- dir, conf_op, transfun, order, data)
- bitmap *in, *out, *gen, *kill;
- bitmap blocks;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_bitmap transfun;
- int *order;
- void *data;
+iterative_dataflow_bitmap (bitmap *in, bitmap *out, bitmap *gen, bitmap *kill,
+ bitmap blocks, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_bitmap transfun, int *order,
+ void *data)
{
int i;
fibheap_t worklist;
OSDN Git Service
