/* Scanning of rtl for dataflow analysis.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009 Free Software Foundation, Inc.
Originally contributed by Michael P. Hayes
(m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
#include "df.h"
#include "tree-pass.h"
+DEF_VEC_P(df_ref);
+DEF_VEC_ALLOC_P_STACK(df_ref);
+
+#define VEC_df_ref_stack_alloc(alloc) VEC_stack_alloc (df_ref, alloc)
+
+typedef struct df_mw_hardreg *df_mw_hardreg_ptr;
+
+DEF_VEC_P(df_mw_hardreg_ptr);
+DEF_VEC_ALLOC_P_STACK(df_mw_hardreg_ptr);
+
+#define VEC_df_mw_hardreg_ptr_stack_alloc(alloc) \
+ VEC_stack_alloc (df_mw_hardreg_ptr, alloc)
+
#ifndef HAVE_epilogue
#define HAVE_epilogue 0
#endif
free (V); \
} while (0)
-/* The bitmap_obstack is used to hold some static variables that
- should not be reset after each function is compiled. */
-
-static bitmap_obstack persistent_obstack;
-
/* The set of hard registers in eliminables[i].from. */
static HARD_REG_SET elim_reg_set;
-/* This is a bitmap copy of regs_invalidated_by_call so that we can
- easily add it into bitmaps, etc. */
-
-bitmap df_invalidated_by_call = NULL;
-
/* Initialize ur_in and ur_out as if all hard registers were partially
available. */
struct df_collection_rec
{
- struct df_ref ** def_vec;
- unsigned int next_def;
- struct df_ref ** use_vec;
- unsigned int next_use;
- struct df_ref ** eq_use_vec;
- unsigned int next_eq_use;
- struct df_mw_hardreg **mw_vec;
- unsigned int next_mw;
+ VEC(df_ref,stack) *def_vec;
+ VEC(df_ref,stack) *use_vec;
+ VEC(df_ref,stack) *eq_use_vec;
+ VEC(df_mw_hardreg_ptr,stack) *mw_vec;
};
-static struct df_ref * df_null_ref_rec[1];
+static df_ref df_null_ref_rec[1];
static struct df_mw_hardreg * df_null_mw_rec[1];
-static void df_ref_record (struct df_collection_rec *,
+static void df_ref_record (enum df_ref_class, struct df_collection_rec *,
rtx, rtx *,
basic_block, struct df_insn_info *,
- enum df_ref_type, enum df_ref_flags,
+ enum df_ref_type, int ref_flags,
int, int, enum machine_mode);
static void df_def_record_1 (struct df_collection_rec *, rtx,
basic_block, struct df_insn_info *,
- enum df_ref_flags);
+ int ref_flags);
static void df_defs_record (struct df_collection_rec *, rtx,
basic_block, struct df_insn_info *,
- enum df_ref_flags);
-static void df_uses_record (struct df_collection_rec *,
+ int ref_flags);
+static void df_uses_record (enum df_ref_class, struct df_collection_rec *,
rtx *, enum df_ref_type,
basic_block, struct df_insn_info *,
- enum df_ref_flags,
+ int ref_flags,
int, int, enum machine_mode);
-static struct df_ref *df_ref_create_structure (struct df_collection_rec *, rtx, rtx *,
- basic_block, struct df_insn_info *,
- enum df_ref_type, enum df_ref_flags,
- int, int, enum machine_mode);
+static df_ref df_ref_create_structure (enum df_ref_class,
+ struct df_collection_rec *, rtx, rtx *,
+ basic_block, struct df_insn_info *,
+ enum df_ref_type, int ref_flags,
+ int, int, enum machine_mode);
static void df_insn_refs_collect (struct df_collection_rec*,
basic_block, struct df_insn_info *);
static void df_get_exit_block_use_set (bitmap);
static void df_get_entry_block_def_set (bitmap);
static void df_grow_ref_info (struct df_ref_info *, unsigned int);
-static void df_ref_chain_delete_du_chain (struct df_ref **);
-static void df_ref_chain_delete (struct df_ref **);
+static void df_ref_chain_delete_du_chain (df_ref *);
+static void df_ref_chain_delete (df_ref *);
static void df_refs_add_to_chains (struct df_collection_rec *,
basic_block, rtx);
static bool df_insn_refs_verify (struct df_collection_rec *, basic_block, rtx, bool);
static void df_entry_block_defs_collect (struct df_collection_rec *, bitmap);
static void df_exit_block_uses_collect (struct df_collection_rec *, bitmap);
-static void df_install_ref (struct df_ref *, struct df_reg_info *,
+static void df_install_ref (df_ref, struct df_reg_info *,
struct df_ref_info *, bool);
static int df_ref_compare (const void *, const void *);
/* Problem data for the scanning dataflow function. */
struct df_scan_problem_data
{
- alloc_pool ref_pool;
+ alloc_pool ref_base_pool;
+ alloc_pool ref_artificial_pool;
+ alloc_pool ref_regular_pool;
alloc_pool ref_extract_pool;
alloc_pool insn_pool;
alloc_pool reg_pool;
BITMAP_FREE (df->insns_to_notes_rescan);
free_alloc_pool (df_scan->block_pool);
- free_alloc_pool (problem_data->ref_pool);
+ free_alloc_pool (problem_data->ref_base_pool);
+ free_alloc_pool (problem_data->ref_artificial_pool);
+ free_alloc_pool (problem_data->ref_regular_pool);
free_alloc_pool (problem_data->ref_extract_pool);
free_alloc_pool (problem_data->insn_pool);
free_alloc_pool (problem_data->reg_pool);
df_scan->problem_data = problem_data;
df_scan->computed = true;
- problem_data->ref_pool
- = create_alloc_pool ("df_scan_ref pool",
- sizeof (struct df_ref), block_size);
+ problem_data->ref_base_pool
+ = create_alloc_pool ("df_scan ref base",
+ sizeof (struct df_base_ref), block_size);
+ problem_data->ref_artificial_pool
+ = create_alloc_pool ("df_scan ref artificial",
+ sizeof (struct df_artificial_ref), block_size);
+ problem_data->ref_regular_pool
+ = create_alloc_pool ("df_scan ref regular",
+ sizeof (struct df_regular_ref), block_size);
problem_data->ref_extract_pool
- = create_alloc_pool ("df_scan_ref extract pool",
- sizeof (struct df_ref_extract), block_size);
+ = create_alloc_pool ("df_scan ref extract",
+ sizeof (struct df_extract_ref), block_size);
problem_data->insn_pool
- = create_alloc_pool ("df_scan_insn pool",
+ = create_alloc_pool ("df_scan insn",
sizeof (struct df_insn_info), block_size);
problem_data->reg_pool
- = create_alloc_pool ("df_scan_reg pool",
+ = create_alloc_pool ("df_scan reg",
sizeof (struct df_reg_info), block_size);
problem_data->mw_reg_pool
- = create_alloc_pool ("df_scan_mw_reg pool",
+ = create_alloc_pool ("df_scan mw_reg",
sizeof (struct df_mw_hardreg), block_size);
bitmap_obstack_initialize (&problem_data->reg_bitmaps);
df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
{
int i;
+ int dcount = 0;
+ int ucount = 0;
+ int ecount = 0;
+ int icount = 0;
+ int ccount = 0;
+ basic_block bb;
+ rtx insn;
fprintf (file, ";; invalidated by call \t");
- df_print_regset (file, df_invalidated_by_call);
+ df_print_regset (file, regs_invalidated_by_call_regset);
fprintf (file, ";; hardware regs used \t");
df_print_regset (file, df->hardware_regs_used);
fprintf (file, ";; regular block artificial uses \t");
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (df_regs_ever_live_p (i))
fprintf (file, " %d[%s]", i, reg_names[i]);
+ fprintf (file, "\n;; ref usage \t");
+
+ for (i = 0; i < (int)df->regs_inited; i++)
+ if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i) || DF_REG_EQ_USE_COUNT (i))
+ {
+ const char * sep = "";
+
+ fprintf (file, "r%d={", i);
+ if (DF_REG_DEF_COUNT (i))
+ {
+ fprintf (file, "%dd", DF_REG_DEF_COUNT (i));
+ sep = ",";
+ dcount += DF_REG_DEF_COUNT (i);
+ }
+ if (DF_REG_USE_COUNT (i))
+ {
+ fprintf (file, "%s%du", sep, DF_REG_USE_COUNT (i));
+ sep = ",";
+ ucount += DF_REG_USE_COUNT (i);
+ }
+ if (DF_REG_EQ_USE_COUNT (i))
+ {
+ fprintf (file, "%s%dd", sep, DF_REG_EQ_USE_COUNT (i));
+ ecount += DF_REG_EQ_USE_COUNT (i);
+ }
+ fprintf (file, "} ");
+ }
+
+ FOR_EACH_BB (bb)
+ FOR_BB_INSNS (bb, insn)
+ if (INSN_P (insn))
+ {
+ if (CALL_P (insn))
+ ccount++;
+ else
+ icount++;
+ }
- fprintf (file, "\n");
+ fprintf (file, "\n;; total ref usage %d{%dd,%du,%de} in %d{%d regular + %d call} insns.\n",
+ dcount + ucount + ecount, dcount, ucount, ecount, icount + ccount, icount, ccount);
}
/* Dump the bb_info for a given basic block. */
{
if (ref_info->refs_size < new_size)
{
- ref_info->refs = XRESIZEVEC (struct df_ref *, ref_info->refs, new_size);
+ ref_info->refs = XRESIZEVEC (df_ref, ref_info->refs, new_size);
memset (ref_info->refs + ref_info->refs_size, 0,
- (new_size - ref_info->refs_size) *sizeof (struct df_ref *));
+ (new_size - ref_info->refs_size) *sizeof (df_ref));
ref_info->refs_size = new_size;
}
}
fields if they were constants. Otherwise they should be -1 if
those flags were set. */
-struct df_ref *
+df_ref
df_ref_create (rtx reg, rtx *loc, rtx insn,
basic_block bb,
enum df_ref_type ref_type,
- enum df_ref_flags ref_flags,
+ int ref_flags,
int width, int offset, enum machine_mode mode)
{
- struct df_ref *ref;
+ df_ref ref;
struct df_reg_info **reg_info;
struct df_ref_info *ref_info;
- struct df_ref **ref_rec;
- struct df_ref ***ref_rec_ptr;
+ df_ref *ref_rec;
+ df_ref **ref_rec_ptr;
unsigned int count = 0;
bool add_to_table;
+ enum df_ref_class cl;
df_grow_reg_info ();
/* You cannot hack artificial refs. */
gcc_assert (insn);
- ref = df_ref_create_structure (NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
+
+ if (width != -1 || offset != -1)
+ cl = DF_REF_EXTRACT;
+ else if (loc)
+ cl = DF_REF_REGULAR;
+ else
+ cl = DF_REF_BASE;
+ ref = df_ref_create_structure (cl, NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
ref_type, ref_flags,
width, offset, mode);
- if (DF_REF_TYPE (ref) == DF_REF_REG_DEF)
+ if (DF_REF_REG_DEF_P (ref))
{
reg_info = df->def_regs;
ref_info = &df->def_info;
ref_rec = *ref_rec_ptr;
if (count)
{
- ref_rec = XRESIZEVEC (struct df_ref *, ref_rec, count+2);
+ ref_rec = XRESIZEVEC (df_ref, ref_rec, count+2);
*ref_rec_ptr = ref_rec;
ref_rec[count] = ref;
ref_rec[count+1] = NULL;
- qsort (ref_rec, count + 1, sizeof (struct df_ref *), df_ref_compare);
+ qsort (ref_rec, count + 1, sizeof (df_ref), df_ref_compare);
}
else
{
- struct df_ref **ref_rec = XNEWVEC (struct df_ref*, 2);
+ df_ref *ref_rec = XNEWVEC (df_ref, 2);
ref_rec[0] = ref;
ref_rec[1] = NULL;
*ref_rec_ptr = ref_rec;
----------------------------------------------------------------------------*/
static void
-df_free_ref (struct df_ref *ref)
+df_free_ref (df_ref ref)
{
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
- if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
- pool_free (problem_data->ref_extract_pool, (struct df_ref_extract *)ref);
- else
- pool_free (problem_data->ref_pool, ref);
+ switch (DF_REF_CLASS (ref))
+ {
+ case DF_REF_BASE:
+ pool_free (problem_data->ref_base_pool, ref);
+ break;
+
+ case DF_REF_ARTIFICIAL:
+ pool_free (problem_data->ref_artificial_pool, ref);
+ break;
+
+ case DF_REF_REGULAR:
+ pool_free (problem_data->ref_regular_pool, ref);
+ break;
+
+ case DF_REF_EXTRACT:
+ pool_free (problem_data->ref_extract_pool, ref);
+ break;
+ }
}
Also delete the def-use or use-def chain if it exists. */
static void
-df_reg_chain_unlink (struct df_ref *ref)
+df_reg_chain_unlink (df_ref ref)
{
- struct df_ref *next = DF_REF_NEXT_REG (ref);
- struct df_ref *prev = DF_REF_PREV_REG (ref);
+ df_ref next = DF_REF_NEXT_REG (ref);
+ df_ref prev = DF_REF_PREV_REG (ref);
int id = DF_REF_ID (ref);
struct df_reg_info *reg_info;
- struct df_ref **refs = NULL;
+ df_ref *refs = NULL;
- if (DF_REF_TYPE (ref) == DF_REF_REG_DEF)
+ if (DF_REF_REG_DEF_P (ref))
{
- reg_info = DF_REG_DEF_GET (DF_REF_REGNO (ref));
+ int regno = DF_REF_REGNO (ref);
+ reg_info = DF_REG_DEF_GET (regno);
refs = df->def_info.refs;
}
else
{
if (df->analyze_subset)
{
- if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BB (ref)->index))
+ if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BBNO (ref)))
refs[id] = NULL;
}
else
/* Remove REF from VEC. */
static void
-df_ref_compress_rec (struct df_ref ***vec_ptr, struct df_ref *ref)
+df_ref_compress_rec (df_ref **vec_ptr, df_ref ref)
{
- struct df_ref **vec = *vec_ptr;
+ df_ref *vec = *vec_ptr;
if (vec[1])
{
/* Unlink REF from all def-use/use-def chains, etc. */
void
-df_ref_remove (struct df_ref *ref)
+df_ref_remove (df_ref ref)
{
#if 0
if (dump_file)
if (DF_REF_IS_ARTIFICIAL (ref))
{
struct df_scan_bb_info *bb_info
- = df_scan_get_bb_info (DF_REF_BB (ref)->index);
+ = df_scan_get_bb_info (DF_REF_BBNO (ref));
df_ref_compress_rec (&bb_info->artificial_defs, ref);
}
else
if (DF_REF_IS_ARTIFICIAL (ref))
{
struct df_scan_bb_info *bb_info
- = df_scan_get_bb_info (DF_REF_BB (ref)->index);
+ = df_scan_get_bb_info (DF_REF_BBNO (ref));
df_ref_compress_rec (&bb_info->artificial_uses, ref);
}
else
/* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain. */
static void
-df_ref_chain_delete_du_chain (struct df_ref **ref_rec)
+df_ref_chain_delete_du_chain (df_ref *ref_rec)
{
while (*ref_rec)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
/* CHAIN is allocated by DF_CHAIN. So make sure to
pass df_scan instance for the problem. */
if (DF_REF_CHAIN (ref))
/* Delete all refs in the ref chain. */
static void
-df_ref_chain_delete (struct df_ref **ref_rec)
+df_ref_chain_delete (df_ref *ref_rec)
{
- struct df_ref **start = ref_rec;
+ df_ref *start = ref_rec;
while (*ref_rec)
{
df_reg_chain_unlink (*ref_rec);
static void
df_free_collection_rec (struct df_collection_rec *collection_rec)
{
+ unsigned int ix;
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
- struct df_ref **ref;
- struct df_mw_hardreg **mw;
-
- if (collection_rec->def_vec)
- for (ref = collection_rec->def_vec; *ref; ref++)
- df_free_ref (*ref);
- if (collection_rec->use_vec)
- for (ref = collection_rec->use_vec; *ref; ref++)
- df_free_ref (*ref);
- if (collection_rec->eq_use_vec)
- for (ref = collection_rec->eq_use_vec; *ref; ref++)
- df_free_ref (*ref);
- if (collection_rec->mw_vec)
- for (mw = collection_rec->mw_vec; *mw; mw++)
- pool_free (problem_data->mw_reg_pool, *mw);
+ df_ref ref;
+ struct df_mw_hardreg *mw;
+
+ for (ix = 0; VEC_iterate (df_ref, collection_rec->def_vec, ix, ref); ++ix)
+ df_free_ref (ref);
+ for (ix = 0; VEC_iterate (df_ref, collection_rec->use_vec, ix, ref); ++ix)
+ df_free_ref (ref);
+ for (ix = 0; VEC_iterate (df_ref, collection_rec->eq_use_vec, ix, ref); ++ix)
+ df_free_ref (ref);
+ for (ix = 0;
+ VEC_iterate (df_mw_hardreg_ptr, collection_rec->mw_vec, ix, mw);
+ ++ix)
+ pool_free (problem_data->mw_reg_pool, mw);
+
+ VEC_free (df_ref, stack, collection_rec->def_vec);
+ VEC_free (df_ref, stack, collection_rec->use_vec);
+ VEC_free (df_ref, stack, collection_rec->eq_use_vec);
+ VEC_free (df_mw_hardreg_ptr, stack, collection_rec->mw_vec);
}
-
/* Rescan INSN. Return TRUE if the rescanning produced any changes. */
bool
struct df_insn_info *insn_info = NULL;
basic_block bb = BLOCK_FOR_INSN (insn);
struct df_collection_rec collection_rec;
- collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
if ((!df) || (!INSN_P (insn)))
return false;
return false;
}
+ collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
+ collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+
bitmap_clear_bit (df->insns_to_delete, uid);
bitmap_clear_bit (df->insns_to_rescan, uid);
bitmap_clear_bit (df->insns_to_notes_rescan, uid);
if (insn_info)
{
+ int luid;
bool the_same = df_insn_refs_verify (&collection_rec, bb, insn, false);
/* If there's no change, return false. */
if (the_same)
if (dump_file)
fprintf (dump_file, "rescanning insn with uid = %d.\n", uid);
- /* There's change - we need to delete the existing info. */
+ /* There's change - we need to delete the existing info.
+ Since the insn isn't moved, we can salvage its LUID. */
+ luid = DF_INSN_LUID (insn);
df_insn_delete (NULL, uid);
df_insn_create_insn_record (insn);
+ DF_INSN_LUID (insn) = luid;
}
else
{
df_refs_add_to_chains (&collection_rec, bb, insn);
df_set_bb_dirty (bb);
+
+ VEC_free (df_ref, stack, collection_rec.def_vec);
+ VEC_free (df_ref, stack, collection_rec.use_vec);
+ VEC_free (df_ref, stack, collection_rec.eq_use_vec);
+ VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
+
return true;
}
ref_info->begin[regno] = offset;
if (include_defs)
{
- struct df_ref *ref = DF_REG_DEF_CHAIN (regno);
+ df_ref ref = DF_REG_DEF_CHAIN (regno);
while (ref)
{
ref_info->refs[offset] = ref;
}
if (include_uses)
{
- struct df_ref *ref = DF_REG_USE_CHAIN (regno);
+ df_ref ref = DF_REG_USE_CHAIN (regno);
while (ref)
{
ref_info->refs[offset] = ref;
}
if (include_eq_uses)
{
- struct df_ref *ref = DF_REG_EQ_USE_CHAIN (regno);
+ df_ref ref = DF_REG_EQ_USE_CHAIN (regno);
while (ref)
{
ref_info->refs[offset] = ref;
{
basic_block bb = BASIC_BLOCK (bb_index);
rtx insn;
- struct df_ref **ref_rec;
+ df_ref *ref_rec;
if (include_defs)
for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
{
basic_block bb = BASIC_BLOCK (bb_index);
rtx insn;
- struct df_ref **ref_rec;
+ df_ref *ref_rec;
if (include_defs)
for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
unsigned int regno = DF_REF_REGNO (ref);
if (regno >= start)
{
if (include_uses)
for (ref_rec = df_get_artificial_uses (bb_index); *ref_rec; ref_rec++)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
unsigned int regno = DF_REF_REGNO (ref);
if (regno >= start)
{
if (include_defs)
for (ref_rec = DF_INSN_UID_DEFS (uid); *ref_rec; ref_rec++)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
unsigned int regno = DF_REF_REGNO (ref);
if (regno >= start)
{
if (include_uses)
for (ref_rec = DF_INSN_UID_USES (uid); *ref_rec; ref_rec++)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
unsigned int regno = DF_REF_REGNO (ref);
if (regno >= start)
{
if (include_eq_uses)
for (ref_rec = DF_INSN_UID_EQ_USES (uid); *ref_rec; ref_rec++)
{
- struct df_ref *ref = *ref_rec;
+ df_ref ref = *ref_rec;
unsigned int regno = DF_REF_REGNO (ref);
if (regno >= start)
{
static unsigned int
df_add_refs_to_table (unsigned int offset,
struct df_ref_info *ref_info,
- struct df_ref **ref_vec)
+ df_ref *ref_vec)
{
while (*ref_vec)
{
- struct df_ref *ref = *ref_vec;
+ df_ref ref = *ref_vec;
if ((!(df->changeable_flags & DF_NO_HARD_REGS))
|| (DF_REF_REGNO (ref) >= FIRST_PSEUDO_REGISTER))
{
}
-/* Change the BB of all refs in the ref chain from OLD_BB to NEW_BB.
- Assumes that all refs in the chain have the same BB. */
-
-static void
-df_ref_chain_change_bb (struct df_ref **ref_rec,
- basic_block old_bb,
- basic_block new_bb)
-{
- while (*ref_rec)
- {
- struct df_ref *ref = *ref_rec;
-
- gcc_assert (DF_REF_BB (ref) == old_bb);
- DF_REF_BB (ref) = new_bb;
- ref_rec++;
- }
-}
-
-
/* Change all of the basic block references in INSN to use the insn's
current basic block. This function is called from routines that move
instructions from one block to another. */
if (!INSN_P (insn))
return;
- df_ref_chain_change_bb (insn_info->defs, old_bb, new_bb);
- df_ref_chain_change_bb (insn_info->uses, old_bb, new_bb);
- df_ref_chain_change_bb (insn_info->eq_uses, old_bb, new_bb);
-
df_set_bb_dirty (new_bb);
if (old_bb)
{
/* Helper function for df_ref_change_reg_with_loc. */
static void
-df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df, struct df_reg_info *new_df,
+df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df,
+ struct df_reg_info *new_df,
int new_regno, rtx loc)
{
- struct df_ref *the_ref = old_df->reg_chain;
+ df_ref the_ref = old_df->reg_chain;
while (the_ref)
{
- if (DF_REF_LOC(the_ref) && (*DF_REF_LOC(the_ref) == loc))
+ if ((!DF_REF_IS_ARTIFICIAL (the_ref))
+ && (DF_REF_LOC (the_ref))
+ && (*DF_REF_LOC (the_ref) == loc))
{
- struct df_ref *next_ref = the_ref->next_reg;
- struct df_ref *prev_ref = the_ref->prev_reg;
- struct df_ref **ref_vec, **ref_vec_t;
+ df_ref next_ref = DF_REF_NEXT_REG (the_ref);
+ df_ref prev_ref = DF_REF_PREV_REG (the_ref);
+ df_ref *ref_vec, *ref_vec_t;
+ struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
unsigned int count = 0;
DF_REF_REGNO (the_ref) = new_regno;
/* Pull the_ref out of the old regno chain. */
if (prev_ref)
- prev_ref->next_reg = next_ref;
+ DF_REF_NEXT_REG (prev_ref) = next_ref;
else
old_df->reg_chain = next_ref;
if (next_ref)
- next_ref->prev_reg = prev_ref;
+ DF_REF_PREV_REG (next_ref) = prev_ref;
old_df->n_refs--;
/* Put the ref into the new regno chain. */
- the_ref->prev_reg = NULL;
- the_ref->next_reg = new_df->reg_chain;
+ DF_REF_PREV_REG (the_ref) = NULL;
+ DF_REF_NEXT_REG (the_ref) = new_df->reg_chain;
if (new_df->reg_chain)
- new_df->reg_chain->prev_reg = the_ref;
+ DF_REF_PREV_REG (new_df->reg_chain) = the_ref;
new_df->reg_chain = the_ref;
new_df->n_refs++;
- df_set_bb_dirty (DF_REF_BB (the_ref));
-
- /* Need to resort the record that the ref was in because the
- regno is a sorting key. First, find the right record. */
- if (DF_REF_IS_ARTIFICIAL (the_ref))
- {
- unsigned int bb_index = DF_REF_BB (the_ref)->index;
- if (DF_REF_REG_DEF_P (the_ref))
- ref_vec = df_get_artificial_defs (bb_index);
- else
- ref_vec = df_get_artificial_uses (bb_index);
- }
+ if (DF_REF_BB (the_ref))
+ df_set_bb_dirty (DF_REF_BB (the_ref));
+
+ /* Need to sort the record again that the ref was in because
+ the regno is a sorting key. First, find the right
+ record. */
+ if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
+ ref_vec = insn_info->eq_uses;
else
- {
- struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
- if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
- ref_vec = insn_info->eq_uses;
- else
- ref_vec = insn_info->uses;
- if (dump_file)
- fprintf (dump_file, "changing reg in insn %d\n",
- INSN_UID (DF_REF_INSN (the_ref)));
- }
+ ref_vec = insn_info->uses;
+ if (dump_file)
+ fprintf (dump_file, "changing reg in insn %d\n",
+ DF_REF_INSN_UID (the_ref));
+
ref_vec_t = ref_vec;
-
+
/* Find the length. */
while (*ref_vec_t)
{
count++;
ref_vec_t++;
}
- qsort (ref_vec, count, sizeof (struct df_ref *), df_ref_compare);
+ qsort (ref_vec, count, sizeof (df_ref ), df_ref_compare);
the_ref = next_ref;
}
else
- the_ref = the_ref->next_reg;
+ the_ref = DF_REF_NEXT_REG (the_ref);
}
}
/* Change the regno of all refs that contained LOC from OLD_REGNO to
- NEW_REGNO. Refs that do not match LOC are not changed. This call
- is to support the SET_REGNO macro. */
+ NEW_REGNO. Refs that do not match LOC are not changed which means
+ that artificial refs are not changed since they have no loc. This
+ call is to support the SET_REGNO macro. */
void
df_ref_change_reg_with_loc (int old_regno, int new_regno, rtx loc)
rtx note;
struct df_collection_rec collection_rec;
unsigned int num_deleted;
+ unsigned int mw_len;
memset (&collection_rec, 0, sizeof (struct df_collection_rec));
- collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 1000);
+ collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
num_deleted = df_mw_hardreg_chain_delete_eq_uses (insn_info);
df_ref_chain_delete (insn_info->eq_uses);
{
case REG_EQUIV:
case REG_EQUAL:
- df_uses_record (&collection_rec,
+ df_uses_record (DF_REF_REGULAR, &collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn_info, DF_REF_IN_NOTE, -1, -1, 0);
+ bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
default:
break;
}
/* Find some place to put any new mw_hardregs. */
df_canonize_collection_rec (&collection_rec);
- if (collection_rec.next_mw)
+ mw_len = VEC_length (df_mw_hardreg_ptr, collection_rec.mw_vec);
+ if (mw_len)
{
unsigned int count = 0;
struct df_mw_hardreg **mw_rec = insn_info->mw_hardregs;
{
/* Append to the end of the existing record after
expanding it if necessary. */
- if (collection_rec.next_mw > num_deleted)
+ if (mw_len > num_deleted)
{
insn_info->mw_hardregs =
XRESIZEVEC (struct df_mw_hardreg *,
- insn_info->mw_hardregs,
- count + 1 + collection_rec.next_mw);
+ insn_info->mw_hardregs,
+ count + 1 + mw_len);
}
- memcpy (&insn_info->mw_hardregs[count], collection_rec.mw_vec,
- (collection_rec.next_mw + 1) * sizeof (struct df_mw_hardreg *));
- qsort (insn_info->mw_hardregs, count + collection_rec.next_mw,
+ memcpy (&insn_info->mw_hardregs[count],
+ VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
+ mw_len * sizeof (struct df_mw_hardreg *));
+ insn_info->mw_hardregs[count + mw_len] = NULL;
+ qsort (insn_info->mw_hardregs, count + mw_len,
sizeof (struct df_mw_hardreg *), df_mw_compare);
}
else
{
/* No vector there. */
insn_info->mw_hardregs
- = XNEWVEC (struct df_mw_hardreg*,
- count + 1 + collection_rec.next_mw);
- memcpy (insn_info->mw_hardregs, collection_rec.mw_vec,
- (collection_rec.next_mw + 1) * sizeof (struct df_mw_hardreg *));
+ = XNEWVEC (struct df_mw_hardreg*, 1 + mw_len);
+ memcpy (insn_info->mw_hardregs,
+ VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
+ mw_len * sizeof (struct df_mw_hardreg *));
+ insn_info->mw_hardregs[mw_len] = NULL;
}
}
/* Get rid of the mw_rec so that df_refs_add_to_chains will
ignore it. */
- collection_rec.mw_vec = NULL;
- collection_rec.next_mw = 0;
+ VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
df_refs_add_to_chains (&collection_rec, bb, insn);
+ VEC_free (df_ref, stack, collection_rec.eq_use_vec);
}
else
df_insn_rescan (insn);
It ignores DF_REF_MARKER. */
static bool
-df_ref_equal_p (struct df_ref *ref1, struct df_ref *ref2)
+df_ref_equal_p (df_ref ref1, df_ref ref2)
{
if (!ref2)
return false;
+
+ if (ref1 == ref2)
+ return true;
+
+ if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2)
+ || DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2)
+ || DF_REF_REG (ref1) != DF_REF_REG (ref2)
+ || DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2)
+ || ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
+ != (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
+ || DF_REF_BB (ref1) != DF_REF_BB (ref2)
+ || DF_REF_INSN_INFO (ref1) != DF_REF_INSN_INFO (ref2))
+ return false;
+
+ switch (DF_REF_CLASS (ref1))
+ {
+ case DF_REF_ARTIFICIAL:
+ case DF_REF_BASE:
+ return true;
- /* The two flag tests here are only to make sure we do not look at
- the offset and width if they are not there. The flags are
- compared in the next set of tests. */
- if ((DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
- && (DF_REF_FLAGS_IS_SET (ref2, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
- && ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
+ case DF_REF_EXTRACT:
+ if ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
|| (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
- || (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))))
- return false;
+ || (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2)))
+ return false;
+ /* fallthru. */
+
+ case DF_REF_REGULAR:
+ return DF_REF_LOC (ref1) == DF_REF_LOC (ref2);
- return (ref1 == ref2) ||
- (DF_REF_REG (ref1) == DF_REF_REG (ref2)
- && DF_REF_REGNO (ref1) == DF_REF_REGNO (ref2)
- && DF_REF_LOC (ref1) == DF_REF_LOC (ref2)
- && DF_REF_INSN_INFO (ref1) == DF_REF_INSN_INFO (ref2)
- && DF_REF_TYPE (ref1) == DF_REF_TYPE (ref2)
- && ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
- == (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
- && DF_REF_BB (ref1) == DF_REF_BB (ref2));
+ default:
+ gcc_unreachable ();
+ }
+ return false;
}
static int
df_ref_compare (const void *r1, const void *r2)
{
- const struct df_ref *const ref1 = *(const struct df_ref *const*)r1;
- const struct df_ref *const ref2 = *(const struct df_ref *const*)r2;
+ const df_ref ref1 = *(const df_ref *)r1;
+ const df_ref ref2 = *(const df_ref *)r2;
if (ref1 == ref2)
return 0;
+ if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2))
+ return (int)DF_REF_CLASS (ref1) - (int)DF_REF_CLASS (ref2);
+
if (DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2))
return (int)DF_REF_REGNO (ref1) - (int)DF_REF_REGNO (ref2);
if (DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2))
return (int)DF_REF_TYPE (ref1) - (int)DF_REF_TYPE (ref2);
- if ((DF_REF_REG (ref1) != DF_REF_REG (ref2))
- || (DF_REF_LOC (ref1) != DF_REF_LOC (ref2)))
+ if (DF_REF_REG (ref1) != DF_REF_REG (ref2))
+ return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
+
+ /* Cannot look at the LOC field on artificial refs. */
+ if (DF_REF_CLASS (ref1) != DF_REF_ARTIFICIAL
+ && DF_REF_LOC (ref1) != DF_REF_LOC (ref2))
return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
if (DF_REF_FLAGS (ref1) != DF_REF_FLAGS (ref2))
return 1;
}
- /* The flags are the same at this point so it is safe to only look
+ /* The classes are the same at this point so it is safe to only look
at ref1. */
- if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
+ if (DF_REF_CLASS (ref1) == DF_REF_EXTRACT)
{
- if (DF_REF_EXTRACT_OFFSET_CONST (ref1) != DF_REF_EXTRACT_OFFSET_CONST (ref2))
- return DF_REF_EXTRACT_OFFSET_CONST (ref1) - DF_REF_EXTRACT_OFFSET_CONST (ref2);
- if (DF_REF_EXTRACT_WIDTH_CONST (ref1) != DF_REF_EXTRACT_WIDTH_CONST (ref2))
- return DF_REF_EXTRACT_WIDTH_CONST (ref1) - DF_REF_EXTRACT_WIDTH_CONST (ref2);
- if (DF_REF_EXTRACT_MODE_CONST (ref1) != DF_REF_EXTRACT_MODE_CONST (ref2))
- return DF_REF_EXTRACT_MODE_CONST (ref1) - DF_REF_EXTRACT_MODE_CONST (ref2);
+ if (DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
+ return DF_REF_EXTRACT_OFFSET (ref1) - DF_REF_EXTRACT_OFFSET (ref2);
+ if (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
+ return DF_REF_EXTRACT_WIDTH (ref1) - DF_REF_EXTRACT_WIDTH (ref2);
+ if (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))
+ return DF_REF_EXTRACT_MODE (ref1) - DF_REF_EXTRACT_MODE (ref2);
}
return 0;
}
static void
-df_swap_refs (struct df_ref **ref_vec, int i, int j)
+df_swap_refs (VEC(df_ref,stack) **ref_vec, int i, int j)
{
- struct df_ref *tmp = ref_vec[i];
- ref_vec[i] = ref_vec[j];
- ref_vec[j] = tmp;
+ df_ref tmp = VEC_index (df_ref, *ref_vec, i);
+ VEC_replace (df_ref, *ref_vec, i, VEC_index (df_ref, *ref_vec, j));
+ VEC_replace (df_ref, *ref_vec, j, tmp);
}
/* Sort and compress a set of refs. */
-static unsigned int
-df_sort_and_compress_refs (struct df_ref **ref_vec, unsigned int count)
+static void
+df_sort_and_compress_refs (VEC(df_ref,stack) **ref_vec)
{
+ unsigned int count;
unsigned int i;
unsigned int dist = 0;
- ref_vec[count] = NULL;
+ count = VEC_length (df_ref, *ref_vec);
+
/* If there are 1 or 0 elements, there is nothing to do. */
if (count < 2)
- return count;
+ return;
else if (count == 2)
{
- if (df_ref_compare (&ref_vec[0], &ref_vec[1]) > 0)
+ df_ref r0 = VEC_index (df_ref, *ref_vec, 0);
+ df_ref r1 = VEC_index (df_ref, *ref_vec, 1);
+ if (df_ref_compare (&r0, &r1) > 0)
df_swap_refs (ref_vec, 0, 1);
}
else
{
for (i = 0; i < count - 1; i++)
- if (df_ref_compare (&ref_vec[i], &ref_vec[i+1]) >= 0)
- break;
+ {
+ df_ref r0 = VEC_index (df_ref, *ref_vec, i);
+ df_ref r1 = VEC_index (df_ref, *ref_vec, i + 1);
+ if (df_ref_compare (&r0, &r1) >= 0)
+ break;
+ }
/* If the array is already strictly ordered,
which is the most common case for large COUNT case
(which happens for CALL INSNs),
Make sure DF_GET_ADD_REFS adds refs in the increasing order
of DF_REF_COMPARE. */
if (i == count - 1)
- return count;
- qsort (ref_vec, count, sizeof (struct df_ref *), df_ref_compare);
+ return;
+ qsort (VEC_address (df_ref, *ref_vec), count, sizeof (df_ref),
+ df_ref_compare);
}
for (i=0; i<count-dist; i++)
{
/* Find the next ref that is not equal to the current ref. */
- while (df_ref_equal_p (ref_vec[i], ref_vec[i + dist + 1]))
+ while (i + dist + 1 < count
+ && df_ref_equal_p (VEC_index (df_ref, *ref_vec, i),
+ VEC_index (df_ref, *ref_vec, i + dist + 1)))
{
- df_free_ref (ref_vec[i + dist + 1]);
+ df_free_ref (VEC_index (df_ref, *ref_vec, i + dist + 1));
dist++;
}
/* Copy it down to the next position. */
- if (dist)
- ref_vec[i+1] = ref_vec[i + dist + 1];
+ if (dist && i + dist + 1 < count)
+ VEC_replace (df_ref, *ref_vec, i + 1,
+ VEC_index (df_ref, *ref_vec, i + dist + 1));
}
count -= dist;
- ref_vec[count] = NULL;
- return count;
+ VEC_truncate (df_ref, *ref_vec, count);
}
/* Sort and compress a set of refs. */
-static unsigned int
-df_sort_and_compress_mws (struct df_mw_hardreg **mw_vec, unsigned int count)
+static void
+df_sort_and_compress_mws (VEC(df_mw_hardreg_ptr,stack) **mw_vec)
{
+ unsigned int count;
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
unsigned int i;
unsigned int dist = 0;
- mw_vec[count] = NULL;
+ count = VEC_length (df_mw_hardreg_ptr, *mw_vec);
if (count < 2)
- return count;
+ return;
else if (count == 2)
{
- if (df_mw_compare (&mw_vec[0], &mw_vec[1]) > 0)
+ struct df_mw_hardreg *m0 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 0);
+ struct df_mw_hardreg *m1 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 1);
+ if (df_mw_compare (&m0, &m1) > 0)
{
- struct df_mw_hardreg *tmp = mw_vec[0];
- mw_vec[0] = mw_vec[1];
- mw_vec[1] = tmp;
+ struct df_mw_hardreg *tmp = VEC_index (df_mw_hardreg_ptr,
+ *mw_vec, 0);
+ VEC_replace (df_mw_hardreg_ptr, *mw_vec, 0,
+ VEC_index (df_mw_hardreg_ptr, *mw_vec, 1));
+ VEC_replace (df_mw_hardreg_ptr, *mw_vec, 1, tmp);
}
}
else
- qsort (mw_vec, count, sizeof (struct df_mw_hardreg *), df_mw_compare);
+ qsort (VEC_address (df_mw_hardreg_ptr, *mw_vec), count,
+ sizeof (struct df_mw_hardreg *), df_mw_compare);
for (i=0; i<count-dist; i++)
{
/* Find the next ref that is not equal to the current ref. */
- while (df_mw_equal_p (mw_vec[i], mw_vec[i + dist + 1]))
+ while (i + dist + 1 < count
+ && df_mw_equal_p (VEC_index (df_mw_hardreg_ptr, *mw_vec, i),
+ VEC_index (df_mw_hardreg_ptr, *mw_vec,
+ i + dist + 1)))
{
- pool_free (problem_data->mw_reg_pool, mw_vec[i + dist + 1]);
+ pool_free (problem_data->mw_reg_pool,
+ VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
dist++;
}
/* Copy it down to the next position. */
- if (dist)
- mw_vec[i+1] = mw_vec[i + dist + 1];
+ if (dist && i + dist + 1 < count)
+ VEC_replace (df_mw_hardreg_ptr, *mw_vec, i + 1,
+ VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
}
count -= dist;
- mw_vec[count] = NULL;
- return count;
+ VEC_truncate (df_mw_hardreg_ptr, *mw_vec, count);
}
static void
df_canonize_collection_rec (struct df_collection_rec *collection_rec)
{
- if (collection_rec->def_vec)
- collection_rec->next_def
- = df_sort_and_compress_refs (collection_rec->def_vec,
- collection_rec->next_def);
- if (collection_rec->use_vec)
- collection_rec->next_use
- = df_sort_and_compress_refs (collection_rec->use_vec,
- collection_rec->next_use);
- if (collection_rec->eq_use_vec)
- collection_rec->next_eq_use
- = df_sort_and_compress_refs (collection_rec->eq_use_vec,
- collection_rec->next_eq_use);
- if (collection_rec->mw_vec)
- collection_rec->next_mw
- = df_sort_and_compress_mws (collection_rec->mw_vec,
- collection_rec->next_mw);
+ df_sort_and_compress_refs (&collection_rec->def_vec);
+ df_sort_and_compress_refs (&collection_rec->use_vec);
+ df_sort_and_compress_refs (&collection_rec->eq_use_vec);
+ df_sort_and_compress_mws (&collection_rec->mw_vec);
}
/* Add the new df_ref to appropriate reg_info/ref_info chains. */
static void
-df_install_ref (struct df_ref *this_ref,
+df_install_ref (df_ref this_ref,
struct df_reg_info *reg_info,
struct df_ref_info *ref_info,
bool add_to_table)
{
unsigned int regno = DF_REF_REGNO (this_ref);
/* Add the ref to the reg_{def,use,eq_use} chain. */
- struct df_ref *head = reg_info->reg_chain;
+ df_ref head = reg_info->reg_chain;
reg_info->reg_chain = this_ref;
reg_info->n_refs++;
eq_uses) and installs the entire group into the insn. It also adds
each of these refs into the appropriate chains. */
-static struct df_ref **
+static df_ref *
df_install_refs (basic_block bb,
- struct df_ref **old_vec, unsigned int count,
+ VEC(df_ref,stack)* old_vec,
struct df_reg_info **reg_info,
struct df_ref_info *ref_info,
bool is_notes)
{
+ unsigned int count;
+
+ count = VEC_length (df_ref, old_vec);
if (count)
{
- unsigned int i;
- struct df_ref **new_vec = XNEWVEC (struct df_ref*, count + 1);
+ df_ref *new_vec = XNEWVEC (df_ref, count + 1);
bool add_to_table;
+ df_ref this_ref;
+ unsigned int ix;
switch (ref_info->ref_order)
{
if (add_to_table && df->analyze_subset)
add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
- for (i = 0; i < count; i++)
+ for (ix = 0; VEC_iterate (df_ref, old_vec, ix, this_ref); ++ix)
{
- struct df_ref *this_ref = old_vec[i];
- new_vec[i] = this_ref;
+ new_vec[ix] = this_ref;
df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)],
ref_info, add_to_table);
}
insn. */
static struct df_mw_hardreg **
-df_install_mws (struct df_mw_hardreg **old_vec, unsigned int count)
+df_install_mws (VEC(df_mw_hardreg_ptr,stack) *old_vec)
{
+ unsigned int count;
+
+ count = VEC_length (df_mw_hardreg_ptr, old_vec);
if (count)
{
struct df_mw_hardreg **new_vec
= XNEWVEC (struct df_mw_hardreg*, count + 1);
- memcpy (new_vec, old_vec,
- sizeof (struct df_mw_hardreg*) * (count + 1));
+ memcpy (new_vec, VEC_address (df_mw_hardreg_ptr, old_vec),
+ sizeof (struct df_mw_hardreg*) * count);
+ new_vec[count] = NULL;
return new_vec;
}
else
{
df_scan_free_ref_vec (insn_rec->defs);
insn_rec->defs
- = df_install_refs (bb, collection_rec->def_vec,
- collection_rec->next_def,
+ = df_install_refs (bb, collection_rec->def_vec,
df->def_regs,
&df->def_info, false);
}
df_scan_free_ref_vec (insn_rec->uses);
insn_rec->uses
= df_install_refs (bb, collection_rec->use_vec,
- collection_rec->next_use,
df->use_regs,
&df->use_info, false);
}
df_scan_free_ref_vec (insn_rec->eq_uses);
insn_rec->eq_uses
= df_install_refs (bb, collection_rec->eq_use_vec,
- collection_rec->next_eq_use,
df->eq_use_regs,
&df->use_info, true);
}
{
df_scan_free_mws_vec (insn_rec->mw_hardregs);
insn_rec->mw_hardregs
- = df_install_mws (collection_rec->mw_vec,
- collection_rec->next_mw);
+ = df_install_mws (collection_rec->mw_vec);
}
}
else
df_scan_free_ref_vec (bb_info->artificial_defs);
bb_info->artificial_defs
- = df_install_refs (bb, collection_rec->def_vec,
- collection_rec->next_def,
+ = df_install_refs (bb, collection_rec->def_vec,
df->def_regs,
&df->def_info, false);
df_scan_free_ref_vec (bb_info->artificial_uses);
bb_info->artificial_uses
= df_install_refs (bb, collection_rec->use_vec,
- collection_rec->next_use,
df->use_regs,
&df->use_info, false);
}
if they were constants. Otherwise they should be -1 if those flags
were set. */
-static struct df_ref *
-df_ref_create_structure (struct df_collection_rec *collection_rec,
+static df_ref
+df_ref_create_structure (enum df_ref_class cl,
+ struct df_collection_rec *collection_rec,
rtx reg, rtx *loc,
basic_block bb, struct df_insn_info *info,
enum df_ref_type ref_type,
- enum df_ref_flags ref_flags,
+ int ref_flags,
int width, int offset, enum machine_mode mode)
{
- struct df_ref *this_ref;
+ df_ref this_ref = NULL;
int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
struct df_scan_problem_data *problem_data
= (struct df_scan_problem_data *) df_scan->problem_data;
- if (ref_flags & (DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
+ switch (cl)
{
- this_ref = (struct df_ref *) pool_alloc (problem_data->ref_extract_pool);
+ case DF_REF_BASE:
+ this_ref = (df_ref) pool_alloc (problem_data->ref_base_pool);
+ gcc_assert (loc == NULL);
+ break;
+
+ case DF_REF_ARTIFICIAL:
+ this_ref = (df_ref) pool_alloc (problem_data->ref_artificial_pool);
+ this_ref->artificial_ref.bb = bb;
+ gcc_assert (loc == NULL);
+ break;
+
+ case DF_REF_REGULAR:
+ this_ref = (df_ref) pool_alloc (problem_data->ref_regular_pool);
+ this_ref->regular_ref.loc = loc;
+ gcc_assert (loc);
+ break;
+
+ case DF_REF_EXTRACT:
+ this_ref = (df_ref) pool_alloc (problem_data->ref_extract_pool);
DF_REF_EXTRACT_WIDTH (this_ref) = width;
DF_REF_EXTRACT_OFFSET (this_ref) = offset;
DF_REF_EXTRACT_MODE (this_ref) = mode;
+ this_ref->regular_ref.loc = loc;
+ gcc_assert (loc);
+ break;
}
- else
- this_ref = (struct df_ref *) pool_alloc (problem_data->ref_pool);
+
+ DF_REF_CLASS (this_ref) = cl;
DF_REF_ID (this_ref) = -1;
DF_REF_REG (this_ref) = reg;
DF_REF_REGNO (this_ref) = regno;
- DF_REF_LOC (this_ref) = loc;
+ DF_REF_TYPE (this_ref) = ref_type;
DF_REF_INSN_INFO (this_ref) = info;
DF_REF_CHAIN (this_ref) = NULL;
- DF_REF_TYPE (this_ref) = ref_type;
DF_REF_FLAGS (this_ref) = ref_flags;
- DF_REF_BB (this_ref) = bb;
DF_REF_NEXT_REG (this_ref) = NULL;
DF_REF_PREV_REG (this_ref) = NULL;
DF_REF_ORDER (this_ref) = df->ref_order++;
if ((regno < FIRST_PSEUDO_REGISTER)
&& (!DF_REF_IS_ARTIFICIAL (this_ref)))
{
- if (DF_REF_TYPE (this_ref) == DF_REF_REG_DEF)
+ if (DF_REF_REG_DEF_P (this_ref))
{
if (!DF_REF_FLAGS_IS_SET (this_ref, DF_REF_MAY_CLOBBER))
DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
if (collection_rec)
{
- if (DF_REF_TYPE (this_ref) == DF_REF_REG_DEF)
- collection_rec->def_vec[collection_rec->next_def++] = this_ref;
+ if (DF_REF_REG_DEF_P (this_ref))
+ VEC_safe_push (df_ref, stack, collection_rec->def_vec, this_ref);
else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
- collection_rec->eq_use_vec[collection_rec->next_eq_use++] = this_ref;
+ VEC_safe_push (df_ref, stack, collection_rec->eq_use_vec, this_ref);
else
- collection_rec->use_vec[collection_rec->next_use++] = this_ref;
+ VEC_safe_push (df_ref, stack, collection_rec->use_vec, this_ref);
}
return this_ref;
static void
-df_ref_record (struct df_collection_rec *collection_rec,
+df_ref_record (enum df_ref_class cl,
+ struct df_collection_rec *collection_rec,
rtx reg, rtx *loc,
basic_block bb, struct df_insn_info *insn_info,
enum df_ref_type ref_type,
- enum df_ref_flags ref_flags,
+ int ref_flags,
int width, int offset, enum machine_mode mode)
{
unsigned int regno;
= (struct df_scan_problem_data *) df_scan->problem_data;
unsigned int i;
unsigned int endregno;
- struct df_ref *ref;
+ df_ref ref;
if (GET_CODE (reg) == SUBREG)
{
hardreg->start_regno = regno;
hardreg->end_regno = endregno - 1;
hardreg->mw_order = df->ref_order++;
- collection_rec->mw_vec[collection_rec->next_mw++] = hardreg;
+ VEC_safe_push (df_mw_hardreg_ptr, stack, collection_rec->mw_vec,
+ hardreg);
}
for (i = regno; i < endregno; i++)
{
- ref = df_ref_create_structure (collection_rec, regno_reg_rtx[i], loc,
+ ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc,
bb, insn_info, ref_type, ref_flags,
width, offset, mode);
}
else
{
- struct df_ref *ref;
- ref = df_ref_create_structure (collection_rec, reg, loc, bb, insn_info,
- ref_type, ref_flags, width, offset, mode);
+ df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info,
+ ref_type, ref_flags, width, offset, mode);
}
}
static void
df_def_record_1 (struct df_collection_rec *collection_rec,
rtx x, basic_block bb, struct df_insn_info *insn_info,
- enum df_ref_flags flags)
+ int flags)
{
rtx *loc;
rtx dst;
int offset = -1;
int width = -1;
- enum machine_mode mode = 0;
+ enum machine_mode mode = VOIDmode;
+ enum df_ref_class cl = DF_REF_REGULAR;
/* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
construct. */
{
flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT;
- if (GET_CODE (XEXP (dst, 1)) == CONST_INT
- && GET_CODE (XEXP (dst, 2)) == CONST_INT)
+ if (CONST_INT_P (XEXP (dst, 1))
+ && CONST_INT_P (XEXP (dst, 2)))
{
width = INTVAL (XEXP (dst, 1));
offset = INTVAL (XEXP (dst, 2));
mode = GET_MODE (dst);
+ cl = DF_REF_EXTRACT;
}
loc = &XEXP (dst, 0);
/* At this point if we do not have a reg or a subreg, just return. */
if (REG_P (dst))
{
- df_ref_record (collection_rec,
+ df_ref_record (cl, collection_rec,
dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
width, offset, mode);
/* We want to keep sp alive everywhere - by making all
writes to sp also use of sp. */
if (REGNO (dst) == STACK_POINTER_REGNUM)
- df_ref_record (collection_rec,
+ df_ref_record (DF_REF_BASE, collection_rec,
dst, NULL, bb, insn_info, DF_REF_REG_USE, flags,
width, offset, mode);
}
flags |= DF_REF_SUBREG;
- df_ref_record (collection_rec,
+ df_ref_record (cl, collection_rec,
dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
width, offset, mode);
}
static void
df_defs_record (struct df_collection_rec *collection_rec,
rtx x, basic_block bb, struct df_insn_info *insn_info,
- enum df_ref_flags flags)
+ int flags)
{
RTX_CODE code = GET_CODE (x);
if (code == SET || code == CLOBBER)
{
/* Mark the single def within the pattern. */
- enum df_ref_flags clobber_flags = flags;
+ int clobber_flags = flags;
clobber_flags |= (code == CLOBBER) ? DF_REF_MUST_CLOBBER : 0;
df_def_record_1 (collection_rec, x, bb, insn_info, clobber_flags);
}
those flags were set. */
static void
-df_uses_record (struct df_collection_rec *collection_rec,
+df_uses_record (enum df_ref_class cl, struct df_collection_rec *collection_rec,
rtx *loc, enum df_ref_type ref_type,
basic_block bb, struct df_insn_info *insn_info,
- enum df_ref_flags flags,
+ int flags,
int width, int offset, enum machine_mode mode)
{
RTX_CODE code;
/* If we are clobbering a MEM, mark any registers inside the address
as being used. */
if (MEM_P (XEXP (x, 0)))
- df_uses_record (collection_rec,
+ df_uses_record (cl, collection_rec,
&XEXP (XEXP (x, 0), 0),
DF_REF_REG_MEM_STORE,
bb, insn_info,
return;
case MEM:
- df_uses_record (collection_rec,
+ df_uses_record (cl, collection_rec,
&XEXP (x, 0), DF_REF_REG_MEM_LOAD,
bb, insn_info, flags & DF_REF_IN_NOTE,
width, offset, mode);
if (!REG_P (SUBREG_REG (x)))
{
loc = &SUBREG_REG (x);
- df_uses_record (collection_rec, loc, ref_type, bb, insn_info, flags,
+ df_uses_record (cl, collection_rec, loc, ref_type, bb, insn_info, flags,
width, offset, mode);
return;
}
/* ... Fall through ... */
case REG:
- df_ref_record (collection_rec,
+ df_ref_record (cl, collection_rec,
x, loc, bb, insn_info,
ref_type, flags,
width, offset, mode);
/* If the parameters to the zero or sign extract are
constants, strip them off and recurse, otherwise there is
no information that we can gain from this operation. */
- if (GET_CODE (XEXP (x, 1)) == CONST_INT
- && GET_CODE (XEXP (x, 2)) == CONST_INT)
+ if (CONST_INT_P (XEXP (x, 1))
+ && CONST_INT_P (XEXP (x, 2)))
{
width = INTVAL (XEXP (x, 1));
offset = INTVAL (XEXP (x, 2));
else
flags |= DF_REF_SIGN_EXTRACT;
- df_uses_record (collection_rec,
+ df_uses_record (DF_REF_EXTRACT, collection_rec,
&XEXP (x, 0), ref_type, bb, insn_info, flags,
width, offset, mode);
return;
{
rtx dst = SET_DEST (x);
gcc_assert (!(flags & DF_REF_IN_NOTE));
- df_uses_record (collection_rec,
+ df_uses_record (cl, collection_rec,
&SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
case SUBREG:
if (df_read_modify_subreg_p (dst))
{
- df_uses_record (collection_rec, &SUBREG_REG (dst),
+ df_uses_record (cl, collection_rec, &SUBREG_REG (dst),
DF_REF_REG_USE, bb, insn_info,
flags | DF_REF_READ_WRITE | DF_REF_SUBREG,
width, offset, mode);
case CC0:
break;
case MEM:
- df_uses_record (collection_rec, &XEXP (dst, 0),
+ df_uses_record (cl, collection_rec, &XEXP (dst, 0),
DF_REF_REG_MEM_STORE, bb, insn_info, flags,
width, offset, mode);
break;
/* A strict_low_part uses the whole REG and not just the
SUBREG. */
dst = XEXP (dst, 0);
- df_uses_record (collection_rec,
+ df_uses_record (cl, collection_rec,
(GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
DF_REF_REG_USE, bb, insn_info,
DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART,
break;
case ZERO_EXTRACT:
{
- if (GET_CODE (XEXP (dst, 1)) == CONST_INT
- && GET_CODE (XEXP (dst, 2)) == CONST_INT)
+ if (CONST_INT_P (XEXP (dst, 1))
+ && CONST_INT_P (XEXP (dst, 2)))
{
width = INTVAL (XEXP (dst, 1));
offset = INTVAL (XEXP (dst, 2));
mode = GET_MODE (dst);
+ df_uses_record (DF_REF_EXTRACT, collection_rec, &XEXP (dst, 0),
+ DF_REF_REG_USE, bb, insn_info,
+ DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
+ width, offset, mode);
}
else
{
- df_uses_record (collection_rec, &XEXP (dst, 1),
+ df_uses_record (cl, collection_rec, &XEXP (dst, 1),
DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
- df_uses_record (collection_rec, &XEXP (dst, 2),
+ df_uses_record (cl, collection_rec, &XEXP (dst, 2),
DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
+ df_uses_record (cl, collection_rec, &XEXP (dst, 0),
+ DF_REF_REG_USE, bb, insn_info,
+ DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
+ width, offset, mode);
}
- df_uses_record (collection_rec, &XEXP (dst, 0),
- DF_REF_REG_USE, bb, insn_info,
- DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
- width, offset, mode);
}
break;
int j;
for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
- df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
+ df_uses_record (cl, collection_rec, &ASM_OPERANDS_INPUT (x, j),
DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
return;
case PRE_MODIFY:
case POST_MODIFY:
/* Catch the def of the register being modified. */
- df_ref_record (collection_rec, XEXP (x, 0), &XEXP (x, 0),
+ df_ref_record (cl, collection_rec, XEXP (x, 0), &XEXP (x, 0),
bb, insn_info,
DF_REF_REG_DEF,
flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY,
loc = &XEXP (x, 0);
goto retry;
}
- df_uses_record (collection_rec, &XEXP (x, i), ref_type,
+ df_uses_record (cl, collection_rec, &XEXP (x, i), ref_type,
bb, insn_info, flags,
width, offset, mode);
}
{
int j;
for (j = 0; j < XVECLEN (x, i); j++)
- df_uses_record (collection_rec,
+ df_uses_record (cl, collection_rec,
&XVECEXP (x, i, j), ref_type,
bb, insn_info, flags,
width, offset, mode);
static void
df_get_conditional_uses (struct df_collection_rec *collection_rec)
{
- unsigned int i;
- for (i = 0; i < collection_rec->next_def; i++)
+ unsigned int ix;
+ df_ref ref;
+
+ for (ix = 0; VEC_iterate (df_ref, collection_rec->def_vec, ix, ref); ++ix)
{
- struct df_ref *ref = collection_rec->def_vec[i];
if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
{
int width = -1;
int offset = -1;
- enum machine_mode mode = 0;
- struct df_ref *use;
+ enum machine_mode mode = VOIDmode;
+ df_ref use;
if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
{
mode = DF_REF_EXTRACT_MODE (ref);
}
- use = df_ref_create_structure (collection_rec, DF_REF_REG (ref),
+ use = df_ref_create_structure (DF_REF_CLASS (ref), collection_rec, DF_REF_REG (ref),
DF_REF_LOC (ref), DF_REF_BB (ref),
DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL,
df_get_call_refs (struct df_collection_rec * collection_rec,
basic_block bb,
struct df_insn_info *insn_info,
- enum df_ref_flags flags)
+ int flags)
{
rtx note;
bitmap_iterator bi;
unsigned int ui;
bool is_sibling_call;
unsigned int i;
+ df_ref def;
bitmap defs_generated = BITMAP_ALLOC (&df_bitmap_obstack);
/* Do not generate clobbers for registers that are the result of the
call. This causes ordering problems in the chain building code
depending on which def is seen first. */
- for (i=0; i<collection_rec->next_def; i++)
- {
- struct df_ref *def = collection_rec->def_vec[i];
- bitmap_set_bit (defs_generated, DF_REF_REGNO (def));
- }
+ for (i = 0; VEC_iterate (df_ref, collection_rec->def_vec, i, def); ++i)
+ bitmap_set_bit (defs_generated, DF_REF_REGNO (def));
/* Record the registers used to pass arguments, and explicitly
noted as clobbered. */
note = XEXP (note, 1))
{
if (GET_CODE (XEXP (note, 0)) == USE)
- df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
- DF_REF_REG_USE, bb, insn_info, flags, -1, -1, 0);
+ df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (XEXP (note, 0), 0),
+ DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
+ VOIDmode);
else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
{
if (REG_P (XEXP (XEXP (note, 0), 0)))
insn_info, flags);
}
else
- df_uses_record (collection_rec, &XEXP (note, 0),
- DF_REF_REG_USE, bb, insn_info, flags, -1, -1, 0);
+ df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (note, 0),
+ DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
+ VOIDmode);
}
}
/* The stack ptr is used (honorarily) by a CALL insn. */
- df_ref_record (collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
+ df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
NULL, bb, insn_info, DF_REF_REG_USE,
DF_REF_CALL_STACK_USAGE | flags,
- -1, -1, 0);
+ -1, -1, VOIDmode);
/* 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])
{
- df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1, 0);
- df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1, 0);
+ df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
+ NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1,
+ VOIDmode);
+ df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
+ NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1,
+ VOIDmode);
}
is_sibling_call = SIBLING_CALL_P (insn_info->insn);
- EXECUTE_IF_SET_IN_BITMAP (df_invalidated_by_call, 0, ui, bi)
+ EXECUTE_IF_SET_IN_BITMAP (regs_invalidated_by_call_regset, 0, ui, bi)
{
if (!global_regs[ui]
&& (!bitmap_bit_p (defs_generated, ui))
|| !bitmap_bit_p (df->exit_block_uses, ui)
|| refers_to_regno_p (ui, ui+1,
crtl->return_rtx, NULL)))
- df_ref_record (collection_rec, regno_reg_rtx[ui],
+ df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[ui],
NULL, bb, insn_info, DF_REF_REG_DEF,
DF_REF_MAY_CLOBBER | flags,
- -1, -1, 0);
+ -1, -1, VOIDmode);
}
BITMAP_FREE (defs_generated);
bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
/* Clear out the collection record. */
- collection_rec->next_def = 0;
- collection_rec->next_use = 0;
- collection_rec->next_eq_use = 0;
- collection_rec->next_mw = 0;
+ VEC_truncate (df_ref, collection_rec->def_vec, 0);
+ VEC_truncate (df_ref, collection_rec->use_vec, 0);
+ VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
+ VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
/* Record register defs. */
df_defs_record (collection_rec, PATTERN (insn_info->insn), bb, insn_info, 0);
{
case REG_EQUIV:
case REG_EQUAL:
- df_uses_record (collection_rec,
+ df_uses_record (DF_REF_REGULAR, collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn_info, DF_REF_IN_NOTE, -1, -1, 0);
+ bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
break;
case REG_NON_LOCAL_GOTO:
/* The frame ptr is used by a non-local goto. */
- df_ref_record (collection_rec,
+ df_ref_record (DF_REF_BASE, collection_rec,
regno_reg_rtx[FRAME_POINTER_REGNUM],
NULL, bb, insn_info,
- DF_REF_REG_USE, 0, -1, -1, 0);
+ DF_REF_REG_USE, 0, -1, -1, VOIDmode);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- df_ref_record (collection_rec,
+ df_ref_record (DF_REF_BASE, collection_rec,
regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
NULL, bb, insn_info,
- DF_REF_REG_USE, 0, -1, -1, 0);
+ DF_REF_REG_USE, 0, -1, -1, VOIDmode);
#endif
break;
default:
(is_cond_exec) ? DF_REF_CONDITIONAL : 0);
/* Record the register uses. */
- df_uses_record (collection_rec,
+ df_uses_record (DF_REF_REGULAR, collection_rec,
&PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0,
- -1, -1, 0);
+ -1, -1, VOIDmode);
/* DF_REF_CONDITIONAL needs corresponding USES. */
if (is_cond_exec)
static void
df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
{
- collection_rec->next_def = 0;
- collection_rec->next_use = 0;
- collection_rec->next_eq_use = 0;
- collection_rec->next_mw = 0;
+ VEC_truncate (df_ref, collection_rec->def_vec, 0);
+ VEC_truncate (df_ref, collection_rec->use_vec, 0);
+ VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
+ VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
if (bb->index == ENTRY_BLOCK)
{
unsigned regno = EH_RETURN_DATA_REGNO (i);
if (regno == INVALID_REGNUM)
break;
- df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
- bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
+ bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1,
+ VOIDmode);
}
}
#endif
-
-#ifdef EH_USES
- if (bb_has_eh_pred (bb))
- {
- unsigned int i;
- /* This code is putting in an artificial ref for the use at the
- TOP of the block that receives the exception. It is too
- cumbersome to actually put the ref on the edge. We could
- either model this at the top of the receiver block or the
- bottom of the sender block.
-
- The bottom of the sender block is problematic because not all
- out-edges of a block are eh-edges. However, it is true
- that all edges into a block are either eh-edges or none of
- them are eh-edges. Thus, we can model this at the top of the
- eh-receiver for all of the edges at once. */
- for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (EH_USES (i))
- df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP, -1, -1, 0);
- }
-#endif
-
/* Add the hard_frame_pointer if this block is the target of a
non-local goto. */
if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
- df_ref_record (collection_rec, hard_frame_pointer_rtx, NULL,
- bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, hard_frame_pointer_rtx, NULL,
+ bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, VOIDmode);
/* Add the artificial uses. */
if (bb->index >= NUM_FIXED_BLOCKS)
EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
{
- df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
- bb, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
+ bb, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
}
}
int luid = 0;
struct df_scan_bb_info *bb_info;
struct df_collection_rec collection_rec;
- collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
if (!df)
return;
bb_info->artificial_uses = NULL;
}
+ collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
+ collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
+
if (scan_insns)
/* Scan the block an insn at a time from beginning to end. */
FOR_BB_INSNS (bb, insn)
df_bb_refs_collect (&collection_rec, bb);
df_refs_add_to_chains (&collection_rec, bb, NULL);
+ VEC_free (df_ref, stack, collection_rec.def_vec);
+ VEC_free (df_ref, stack, collection_rec.use_vec);
+ VEC_free (df_ref, stack, collection_rec.eq_use_vec);
+ VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
+
/* Now that the block has been processed, set the block as dirty so
LR and LIVE will get it processed. */
df_set_bb_dirty (bb);
static void
df_get_regular_block_artificial_uses (bitmap regular_block_artificial_uses)
{
+#ifdef EH_USES
+ unsigned int i;
+#endif
+
bitmap_clear (regular_block_artificial_uses);
if (reload_completed)
}
/* The all-important stack pointer must always be live. */
bitmap_set_bit (regular_block_artificial_uses, STACK_POINTER_REGNUM);
+
+#ifdef EH_USES
+ /* EH_USES registers are used:
+ 1) at all insns that might throw (calls or with -fnon-call-exceptions
+ trapping insns)
+ 2) in all EH edges
+ 3) to support backtraces and/or debugging, anywhere between their
+ initialization and where they the saved registers are restored
+ from them, including the cases where we don't reach the epilogue
+ (noreturn call or infinite loop). */
+ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ if (EH_USES (i))
+ bitmap_set_bit (regular_block_artificial_uses, i);
+#endif
}
#endif
}
+ /* The always important stack pointer. */
+ bitmap_set_bit (entry_block_defs, STACK_POINTER_REGNUM);
+
/* Once the prologue has been generated, all of these registers
should just show up in the first regular block. */
if (HAVE_prologue && epilogue_completed)
}
else
{
- /* The always important stack pointer. */
- bitmap_set_bit (entry_block_defs, STACK_POINTER_REGNUM);
-
/* If STATIC_CHAIN_INCOMING_REGNUM == STATIC_CHAIN_REGNUM
only STATIC_CHAIN_REGNUM is defined. If they are different,
we only care about the STATIC_CHAIN_INCOMING_REGNUM. */
/* These registers are live everywhere. */
if (!reload_completed)
{
-#ifdef EH_USES
- /* The ia-64, the only machine that uses this, does not define these
- until after reload. */
- for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (EH_USES (i))
- {
- bitmap_set_bit (entry_block_defs, i);
- }
-#endif
-
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
/* Pseudos with argument area equivalences may require
reloading via the argument pointer. */
EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
{
- df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
+ ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1,
+ VOIDmode);
}
df_canonize_collection_rec (collection_rec);
{
struct df_collection_rec collection_rec;
memset (&collection_rec, 0, sizeof (struct df_collection_rec));
- collection_rec.def_vec = XALLOCAVEC (struct df_ref *, FIRST_PSEUDO_REGISTER);
-
+ collection_rec.def_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
df_entry_block_defs_collect (&collection_rec, entry_block_defs);
/* Process bb_refs chain */
df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (ENTRY_BLOCK), NULL);
+ VEC_free (df_ref, stack, collection_rec.def_vec);
}
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
- df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
+ EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
/* It is deliberate that this is not put in the exit block uses but
&& !bitmap_bit_p (exit_block_uses, ARG_POINTER_REGNUM)
&& bb_has_eh_pred (EXIT_BLOCK_PTR)
&& fixed_regs[ARG_POINTER_REGNUM])
- df_ref_record (collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
- EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
+ df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
+ EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
#endif
df_canonize_collection_rec (collection_rec);
{
struct df_collection_rec collection_rec;
memset (&collection_rec, 0, sizeof (struct df_collection_rec));
- collection_rec.use_vec = XALLOCAVEC (struct df_ref *, FIRST_PSEUDO_REGISTER);
+ collection_rec.use_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
df_exit_block_uses_collect (&collection_rec, exit_block_uses);
/* Process bb_refs chain */
df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (EXIT_BLOCK), NULL);
+ VEC_free (df_ref, stack, collection_rec.use_vec);
}
void
df_hard_reg_init (void)
{
- int i;
#ifdef ELIMINABLE_REGS
+ int i;
static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
#endif
if (initialized)
return;
- bitmap_obstack_initialize (&persistent_obstack);
-
/* Record which registers will be eliminated. We use this in
mark_used_regs. */
CLEAR_HARD_REG_SET (elim_reg_set);
SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);
#endif
- df_invalidated_by_call = BITMAP_ALLOC (&persistent_obstack);
-
- /* Inconveniently, this is only readily available in hard reg set
- form. */
- for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
- if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
- bitmap_set_bit (df_invalidated_by_call, i);
-
initialized = true;
}
df_reg_chain_mark (refs, regno, is_def, is_eq_use)
df_reg_chain_verify_unmarked (refs)
- df_refs_verify (ref*, ref*, bool)
+ df_refs_verify (VEC(stack,df_ref)*, ref*, bool)
df_mws_verify (mw*, mw*, bool)
df_insn_refs_verify (collection_rec, bb, insn, bool)
df_bb_refs_verify (bb, refs, bool)
are in the correct chain. */
static unsigned int
-df_reg_chain_mark (struct df_ref *refs, unsigned int regno,
+df_reg_chain_mark (df_ref refs, unsigned int regno,
bool is_def, bool is_eq_use)
{
unsigned int count = 0;
- struct df_ref *ref;
+ df_ref ref;
for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
{
gcc_assert (!DF_REF_IS_REG_MARKED (ref));
/* Check to make sure the ref is in the correct chain. */
gcc_assert (DF_REF_REGNO (ref) == regno);
if (is_def)
- gcc_assert (DF_REF_TYPE(ref) == DF_REF_REG_DEF);
+ gcc_assert (DF_REF_REG_DEF_P (ref));
else
- gcc_assert (DF_REF_TYPE(ref) != DF_REF_REG_DEF);
+ gcc_assert (!DF_REF_REG_DEF_P (ref));
if (is_eq_use)
gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE));
else
gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) == 0);
- if (ref->next_reg)
- gcc_assert (ref->next_reg->prev_reg == ref);
+ if (DF_REF_NEXT_REG (ref))
+ gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref)) == ref);
count++;
DF_REF_REG_MARK (ref);
}
/* Verify that all of the registers in the chain are unmarked. */
static void
-df_reg_chain_verify_unmarked (struct df_ref *refs)
+df_reg_chain_verify_unmarked (df_ref refs)
{
- struct df_ref *ref;
+ df_ref ref;
for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
gcc_assert (!DF_REF_IS_REG_MARKED (ref));
}
/* Verify that NEW_REC and OLD_REC have exactly the same members. */
static bool
-df_refs_verify (struct df_ref **new_rec, struct df_ref **old_rec,
+df_refs_verify (VEC(df_ref,stack) *new_rec, df_ref *old_rec,
bool abort_if_fail)
{
- while ((*new_rec) && (*old_rec))
+ unsigned int ix;
+ df_ref new_ref;
+
+ for (ix = 0; VEC_iterate (df_ref, new_rec, ix, new_ref); ++ix)
{
- if (!df_ref_equal_p (*new_rec, *old_rec))
+ if (*old_rec == NULL || !df_ref_equal_p (new_ref, *old_rec))
{
if (abort_if_fail)
gcc_assert (0);
DF_REF_REG_UNMARK (*old_rec);
}
- new_rec++;
old_rec++;
}
if (abort_if_fail)
- gcc_assert ((*new_rec == NULL) && (*old_rec == NULL));
+ gcc_assert (*old_rec == NULL);
else
- return ((*new_rec == NULL) && (*old_rec == NULL));
+ return *old_rec == NULL;
return false;
}
/* Verify that NEW_REC and OLD_REC have exactly the same members. */
static bool
-df_mws_verify (struct df_mw_hardreg **new_rec, struct df_mw_hardreg **old_rec,
+df_mws_verify (VEC(df_mw_hardreg_ptr,stack) *new_rec,
+ struct df_mw_hardreg **old_rec,
bool abort_if_fail)
{
- while ((*new_rec) && (*old_rec))
+ unsigned int ix;
+ struct df_mw_hardreg *new_reg;
+
+ for (ix = 0; VEC_iterate (df_mw_hardreg_ptr, new_rec, ix, new_reg); ++ix)
{
- if (!df_mw_equal_p (*new_rec, *old_rec))
+ if (*old_rec == NULL || !df_mw_equal_p (new_reg, *old_rec))
{
if (abort_if_fail)
gcc_assert (0);
else
return false;
}
- new_rec++;
old_rec++;
}
if (abort_if_fail)
- gcc_assert ((*new_rec == NULL) && (*old_rec == NULL));
+ gcc_assert (*old_rec == NULL);
else
- return ((*new_rec == NULL) && (*old_rec == NULL));
+ return *old_rec == NULL;
return false;
}
struct df_collection_rec collection_rec;
memset (&collection_rec, 0, sizeof (struct df_collection_rec));
- collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
- collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
+ collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
+ collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
+ collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
gcc_assert (bb_info);
- /* Scan the block an insn at a time from beginning to end. */
+ /* Scan the block, one insn at a time, from beginning to end. */
FOR_BB_INSNS_REVERSE (bb, insn)
{
if (!INSN_P (insn))
OSDN Git Service
