diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/df-scan.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/df-scan.c | 2074 |
1 files changed, 2074 insertions, 0 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/df-scan.c b/gcc-4.2.1-5666.3/gcc/df-scan.c new file mode 100644 index 000000000..46dfb072c --- /dev/null +++ b/gcc-4.2.1-5666.3/gcc/df-scan.c @@ -0,0 +1,2074 @@ +/* FIXME: We need to go back and add the warning messages about code + moved across setjmp. */ + + +/* Scanning of rtl for dataflow analysis. + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + 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) + and Kenneth Zadeck (zadeck@naturalbridge.com). + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. +*/ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "rtl.h" +#include "tm_p.h" +#include "insn-config.h" +#include "recog.h" +#include "function.h" +#include "regs.h" +#include "output.h" +#include "alloc-pool.h" +#include "flags.h" +#include "hard-reg-set.h" +#include "basic-block.h" +#include "sbitmap.h" +#include "bitmap.h" +#include "timevar.h" +#include "tree.h" +#include "target.h" +#include "target-def.h" +#include "df.h" + +#ifndef HAVE_epilogue +#define HAVE_epilogue 0 +#endif +#ifndef HAVE_prologue +#define HAVE_prologue 0 +#endif +#ifndef HAVE_sibcall_epilogue +#define HAVE_sibcall_epilogue 0 +#endif + +#ifndef EPILOGUE_USES +#define EPILOGUE_USES(REGNO) 0 +#endif + +/* 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. */ + +static void df_ref_record (struct dataflow *, rtx, rtx *, + basic_block, rtx, enum df_ref_type, + enum df_ref_flags, bool record_live); +static void df_def_record_1 (struct dataflow *, rtx, basic_block, rtx, + enum df_ref_flags, bool record_live); +static void df_defs_record (struct dataflow *, rtx, basic_block, rtx); +static void df_uses_record (struct dataflow *, rtx *, enum df_ref_type, + basic_block, rtx, enum df_ref_flags); + +static void df_insn_refs_record (struct dataflow *, basic_block, rtx); +static void df_bb_refs_record (struct dataflow *, basic_block); +static void df_refs_record (struct dataflow *, bitmap); +static struct df_ref *df_ref_create_structure (struct dataflow *, rtx, rtx *, + basic_block, rtx, enum df_ref_type, + enum df_ref_flags); +static void df_record_entry_block_defs (struct dataflow *); +static void df_record_exit_block_uses (struct dataflow *); +static void df_grow_reg_info (struct dataflow *, struct df_ref_info *); +static void df_grow_ref_info (struct df_ref_info *, unsigned int); +static void df_grow_insn_info (struct df *); + + +/*---------------------------------------------------------------------------- + SCANNING DATAFLOW PROBLEM + + There are several ways in which scanning looks just like the other + dataflow problems. It shares the all the mechanisms for local info + as well as basic block info. Where it differs is when and how often + it gets run. It also has no need for the iterative solver. +----------------------------------------------------------------------------*/ + +/* Problem data for the scanning dataflow function. */ +struct df_scan_problem_data +{ + alloc_pool ref_pool; + alloc_pool insn_pool; + alloc_pool reg_pool; + alloc_pool mw_reg_pool; + alloc_pool mw_link_pool; +}; + +typedef struct df_scan_bb_info *df_scan_bb_info_t; + +static void +df_scan_free_internal (struct dataflow *dflow) +{ + struct df *df = dflow->df; + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + + free (df->def_info.regs); + free (df->def_info.refs); + memset (&df->def_info, 0, (sizeof (struct df_ref_info))); + + free (df->use_info.regs); + free (df->use_info.refs); + memset (&df->use_info, 0, (sizeof (struct df_ref_info))); + + free (df->insns); + df->insns = NULL; + df->insns_size = 0; + + free (dflow->block_info); + dflow->block_info = NULL; + dflow->block_info_size = 0; + + BITMAP_FREE (df->hardware_regs_used); + BITMAP_FREE (df->entry_block_defs); + BITMAP_FREE (df->exit_block_uses); + + free_alloc_pool (dflow->block_pool); + free_alloc_pool (problem_data->ref_pool); + free_alloc_pool (problem_data->insn_pool); + free_alloc_pool (problem_data->reg_pool); + free_alloc_pool (problem_data->mw_reg_pool); + free_alloc_pool (problem_data->mw_link_pool); +} + + +/* Get basic block info. */ + +struct df_scan_bb_info * +df_scan_get_bb_info (struct dataflow *dflow, unsigned int index) +{ + gcc_assert (index < dflow->block_info_size); + return (struct df_scan_bb_info *) dflow->block_info[index]; +} + + +/* Set basic block info. */ + +static void +df_scan_set_bb_info (struct dataflow *dflow, unsigned int index, + struct df_scan_bb_info *bb_info) +{ + gcc_assert (index < dflow->block_info_size); + dflow->block_info[index] = (void *) bb_info; +} + + +/* Free basic block info. */ + +static void +df_scan_free_bb_info (struct dataflow *dflow, basic_block bb, void *vbb_info) +{ + struct df_scan_bb_info *bb_info = (struct df_scan_bb_info *) vbb_info; + if (bb_info) + { + df_bb_refs_delete (dflow, bb->index); + pool_free (dflow->block_pool, bb_info); + } +} + + +/* Allocate the problem data for the scanning problem. This should be + called when the problem is created or when the entire function is to + be rescanned. */ + +static void +df_scan_alloc (struct dataflow *dflow, bitmap blocks_to_rescan, + bitmap all_blocks ATTRIBUTE_UNUSED) +{ + struct df *df = dflow->df; + struct df_scan_problem_data *problem_data; + unsigned int insn_num = get_max_uid () + 1; + unsigned int block_size = 50; + unsigned int bb_index; + bitmap_iterator bi; + + /* Given the number of pools, this is really faster than tearing + everything apart. */ + if (dflow->problem_data) + df_scan_free_internal (dflow); + + dflow->block_pool + = create_alloc_pool ("df_scan_block pool", + sizeof (struct df_scan_bb_info), + block_size); + + problem_data = XNEW (struct df_scan_problem_data); + dflow->problem_data = problem_data; + + problem_data->ref_pool + = create_alloc_pool ("df_scan_ref pool", + sizeof (struct df_ref), block_size); + problem_data->insn_pool + = create_alloc_pool ("df_scan_insn pool", + sizeof (struct df_insn_info), block_size); + problem_data->reg_pool + = create_alloc_pool ("df_scan_reg pool", + sizeof (struct df_reg_info), block_size); + problem_data->mw_reg_pool + = create_alloc_pool ("df_scan_mw_reg pool", + sizeof (struct df_mw_hardreg), block_size); + problem_data->mw_link_pool + = create_alloc_pool ("df_scan_mw_link pool", + sizeof (struct df_link), block_size); + + insn_num += insn_num / 4; + df_grow_reg_info (dflow, &df->def_info); + df_grow_ref_info (&df->def_info, insn_num); + + df_grow_reg_info (dflow, &df->use_info); + df_grow_ref_info (&df->use_info, insn_num *2); + + df_grow_insn_info (df); + df_grow_bb_info (dflow); + + EXECUTE_IF_SET_IN_BITMAP (blocks_to_rescan, 0, bb_index, bi) + { + struct df_scan_bb_info *bb_info = df_scan_get_bb_info (dflow, bb_index); + if (!bb_info) + { + bb_info = (struct df_scan_bb_info *) pool_alloc (dflow->block_pool); + df_scan_set_bb_info (dflow, bb_index, bb_info); + } + bb_info->artificial_defs = NULL; + bb_info->artificial_uses = NULL; + } + + df->hardware_regs_used = BITMAP_ALLOC (NULL); + df->entry_block_defs = BITMAP_ALLOC (NULL); + df->exit_block_uses = BITMAP_ALLOC (NULL); +} + + +/* Free all of the data associated with the scan problem. */ + +static void +df_scan_free (struct dataflow *dflow) +{ + struct df *df = dflow->df; + + if (dflow->problem_data) + { + df_scan_free_internal (dflow); + free (dflow->problem_data); + } + + if (df->blocks_to_scan) + BITMAP_FREE (df->blocks_to_scan); + + if (df->blocks_to_analyze) + BITMAP_FREE (df->blocks_to_analyze); + + free (dflow); +} + +static void +df_scan_dump (struct dataflow *dflow ATTRIBUTE_UNUSED, FILE *file ATTRIBUTE_UNUSED) +{ + struct df *df = dflow->df; + int i; + + fprintf (file, " invalidated by call \t"); + dump_bitmap (file, df_invalidated_by_call); + fprintf (file, " hardware regs used \t"); + dump_bitmap (file, df->hardware_regs_used); + fprintf (file, " entry block uses \t"); + dump_bitmap (file, df->entry_block_defs); + fprintf (file, " exit block uses \t"); + dump_bitmap (file, df->exit_block_uses); + fprintf (file, " regs ever live \t"); + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + if (regs_ever_live[i]) + fprintf (file, "%d ", i); + fprintf (file, "\n"); +} + +static struct df_problem problem_SCAN = +{ + DF_SCAN, /* Problem id. */ + DF_NONE, /* Direction. */ + df_scan_alloc, /* Allocate the problem specific data. */ + NULL, /* Reset global information. */ + df_scan_free_bb_info, /* Free basic block info. */ + NULL, /* Local compute function. */ + NULL, /* Init the solution specific data. */ + NULL, /* Iterative solver. */ + NULL, /* Confluence operator 0. */ + NULL, /* Confluence operator n. */ + NULL, /* Transfer function. */ + NULL, /* Finalize function. */ + df_scan_free, /* Free all of the problem information. */ + df_scan_dump, /* Debugging. */ + NULL, /* Dependent problem. */ + 0 /* Changeable flags. */ +}; + + +/* Create a new DATAFLOW instance and add it to an existing instance + of DF. The returned structure is what is used to get at the + solution. */ + +struct dataflow * +df_scan_add_problem (struct df *df, int flags) +{ + return df_add_problem (df, &problem_SCAN, flags); +} + +/*---------------------------------------------------------------------------- + Storage Allocation Utilities +----------------------------------------------------------------------------*/ + + +/* First, grow the reg_info information. If the current size is less than + the number of psuedos, grow to 25% more than the number of + pseudos. + + Second, assure that all of the slots up to max_reg_num have been + filled with reg_info structures. */ + +static void +df_grow_reg_info (struct dataflow *dflow, struct df_ref_info *ref_info) +{ + unsigned int max_reg = max_reg_num (); + unsigned int new_size = max_reg; + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + unsigned int i; + + if (ref_info->regs_size < new_size) + { + new_size += new_size / 4; + ref_info->regs = xrealloc (ref_info->regs, + new_size *sizeof (struct df_reg_info*)); + ref_info->regs_size = new_size; + } + + for (i = ref_info->regs_inited; i < max_reg; i++) + { + struct df_reg_info *reg_info = pool_alloc (problem_data->reg_pool); + memset (reg_info, 0, sizeof (struct df_reg_info)); + ref_info->regs[i] = reg_info; + } + + ref_info->regs_inited = max_reg; +} + + +/* Grow the ref information. */ + +static void +df_grow_ref_info (struct df_ref_info *ref_info, unsigned int new_size) +{ + if (ref_info->refs_size < new_size) + { + ref_info->refs = xrealloc (ref_info->refs, + new_size *sizeof (struct df_ref *)); + memset (ref_info->refs + ref_info->refs_size, 0, + (new_size - ref_info->refs_size) *sizeof (struct df_ref *)); + ref_info->refs_size = new_size; + } +} + + +/* Grow the ref information. If the current size is less than the + number of instructions, grow to 25% more than the number of + instructions. */ + +static void +df_grow_insn_info (struct df *df) +{ + unsigned int new_size = get_max_uid () + 1; + if (df->insns_size < new_size) + { + new_size += new_size / 4; + df->insns = xrealloc (df->insns, + new_size *sizeof (struct df_insn_info *)); + memset (df->insns + df->insns_size, 0, + (new_size - df->insns_size) *sizeof (struct df_insn_info *)); + df->insns_size = new_size; + } +} + + + + +/*---------------------------------------------------------------------------- + PUBLIC INTERFACES FOR SMALL GRAIN CHANGES TO SCANNING. +----------------------------------------------------------------------------*/ + +/* Rescan some BLOCKS or all the blocks defined by the last call to + df_set_blocks if BLOCKS is NULL); */ + +void +df_rescan_blocks (struct df *df, bitmap blocks) +{ + bitmap local_blocks_to_scan = BITMAP_ALLOC (NULL); + + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; + basic_block bb; + + df->def_info.refs_organized = false; + df->use_info.refs_organized = false; + + if (blocks) + { + int i; + unsigned int bb_index; + bitmap_iterator bi; + bool cleared_bits = false; + + /* Need to assure that there are space in all of the tables. */ + unsigned int insn_num = get_max_uid () + 1; + insn_num += insn_num / 4; + + df_grow_reg_info (dflow, &df->def_info); + df_grow_ref_info (&df->def_info, insn_num); + + df_grow_reg_info (dflow, &df->use_info); + df_grow_ref_info (&df->use_info, insn_num *2); + + df_grow_insn_info (df); + df_grow_bb_info (dflow); + + bitmap_copy (local_blocks_to_scan, blocks); + + EXECUTE_IF_SET_IN_BITMAP (blocks, 0, bb_index, bi) + { + basic_block bb = BASIC_BLOCK (bb_index); + if (!bb) + { + bitmap_clear_bit (local_blocks_to_scan, bb_index); + cleared_bits = true; + } + } + + if (cleared_bits) + bitmap_copy (blocks, local_blocks_to_scan); + + df->def_info.add_refs_inline = true; + df->use_info.add_refs_inline = true; + + for (i = df->num_problems_defined; i; i--) + { + bitmap blocks_to_reset = NULL; + if (dflow->problem->reset_fun) + { + if (!blocks_to_reset) + { + blocks_to_reset = BITMAP_ALLOC (NULL); + bitmap_copy (blocks_to_reset, local_blocks_to_scan); + if (df->blocks_to_scan) + bitmap_ior_into (blocks_to_reset, df->blocks_to_scan); + } + dflow->problem->reset_fun (dflow, blocks_to_reset); + } + if (blocks_to_reset) + BITMAP_FREE (blocks_to_reset); + } + + df_refs_delete (dflow, local_blocks_to_scan); + + /* This may be a mistake, but if an explicit blocks is passed in + and the set of blocks to analyze has been explicitly set, add + the extra blocks to blocks_to_analyze. The alternative is to + put an assert here. We do not want this to just go by + silently or else we may get storage leaks. */ + if (df->blocks_to_analyze) + bitmap_ior_into (df->blocks_to_analyze, blocks); + } + else + { + /* If we are going to do everything, just reallocate everything. + Most stuff is allocated in pools so this is faster than + walking it. */ + if (df->blocks_to_analyze) + bitmap_copy (local_blocks_to_scan, df->blocks_to_analyze); + else + FOR_ALL_BB (bb) + { + bitmap_set_bit (local_blocks_to_scan, bb->index); + } + df_scan_alloc (dflow, local_blocks_to_scan, NULL); + + df->def_info.add_refs_inline = false; + df->use_info.add_refs_inline = false; + } + + df_refs_record (dflow, local_blocks_to_scan); +#if 0 + bitmap_print (stderr, local_blocks_to_scan, "scanning: ", "\n"); +#endif + + if (!df->blocks_to_scan) + df->blocks_to_scan = BITMAP_ALLOC (NULL); + + bitmap_ior_into (df->blocks_to_scan, local_blocks_to_scan); + BITMAP_FREE (local_blocks_to_scan); +} + + +/* Create a new ref of type DF_REF_TYPE for register REG at address + LOC within INSN of BB. */ + +struct df_ref * +df_ref_create (struct df *df, rtx reg, rtx *loc, rtx insn, + basic_block bb, + enum df_ref_type ref_type, + enum df_ref_flags ref_flags) +{ + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; + struct df_scan_bb_info *bb_info; + + df_grow_reg_info (dflow, &df->use_info); + df_grow_reg_info (dflow, &df->def_info); + df_grow_bb_info (dflow); + + /* Make sure there is the bb_info for this block. */ + bb_info = df_scan_get_bb_info (dflow, bb->index); + if (!bb_info) + { + bb_info = (struct df_scan_bb_info *) pool_alloc (dflow->block_pool); + df_scan_set_bb_info (dflow, bb->index, bb_info); + bb_info->artificial_defs = NULL; + bb_info->artificial_uses = NULL; + } + + if (ref_type == DF_REF_REG_DEF) + df->def_info.add_refs_inline = true; + else + df->use_info.add_refs_inline = true; + + return df_ref_create_structure (dflow, reg, loc, bb, insn, ref_type, ref_flags); +} + + + +/*---------------------------------------------------------------------------- + UTILITIES TO CREATE AND DESTROY REFS AND CHAINS. +----------------------------------------------------------------------------*/ + + +/* Get the artificial uses for a basic block. */ + +struct df_ref * +df_get_artificial_defs (struct df *df, unsigned int bb_index) +{ + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; + return df_scan_get_bb_info (dflow, bb_index)->artificial_defs; +} + + +/* Get the artificial uses for a basic block. */ + +struct df_ref * +df_get_artificial_uses (struct df *df, unsigned int bb_index) +{ + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; + return df_scan_get_bb_info (dflow, bb_index)->artificial_uses; +} + + +/* Link REF at the front of reg_use or reg_def chain for REGNO. */ + +void +df_reg_chain_create (struct df_reg_info *reg_info, + struct df_ref *ref) +{ + struct df_ref *head = reg_info->reg_chain; + reg_info->reg_chain = ref; + + DF_REF_NEXT_REG (ref) = head; + + /* We cannot actually link to the head of the chain. */ + DF_REF_PREV_REG (ref) = NULL; + + if (head) + DF_REF_PREV_REG (head) = ref; +} + + +/* Remove REF from the CHAIN. Return the head of the chain. This + will be CHAIN unless the REF was at the beginning of the chain. */ + +static struct df_ref * +df_ref_unlink (struct df_ref *chain, struct df_ref *ref) +{ + struct df_ref *orig_chain = chain; + struct df_ref *prev = NULL; + while (chain) + { + if (chain == ref) + { + if (prev) + { + prev->next_ref = ref->next_ref; + ref->next_ref = NULL; + return orig_chain; + } + else + { + chain = ref->next_ref; + ref->next_ref = NULL; + return chain; + } + } + + prev = chain; + chain = chain->next_ref; + } + + /* Someone passed in a ref that was not in the chain. */ + gcc_unreachable (); + return NULL; +} + + +/* Unlink and delete REF at the reg_use or reg_def chain. Also delete + the def-use or use-def chain if it exists. Returns the next ref in + uses or defs chain. */ + +struct df_ref * +df_reg_chain_unlink (struct dataflow *dflow, struct df_ref *ref) +{ + struct df *df = dflow->df; + struct df_ref *next = DF_REF_NEXT_REG (ref); + struct df_ref *prev = DF_REF_PREV_REG (ref); + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + struct df_reg_info *reg_info; + struct df_ref *next_ref = ref->next_ref; + unsigned int id = DF_REF_ID (ref); + + if (DF_REF_TYPE (ref) == DF_REF_REG_DEF) + { + reg_info = DF_REG_DEF_GET (df, DF_REF_REGNO (ref)); + df->def_info.bitmap_size--; + if (df->def_info.refs && (id < df->def_info.refs_size)) + DF_DEFS_SET (df, id, NULL); + } + else + { + reg_info = DF_REG_USE_GET (df, DF_REF_REGNO (ref)); + df->use_info.bitmap_size--; + if (df->use_info.refs && (id < df->use_info.refs_size)) + DF_USES_SET (df, id, NULL); + } + + /* Delete any def-use or use-def chains that start here. */ + if (DF_REF_CHAIN (ref)) + df_chain_unlink (df->problems_by_index[DF_CHAIN], ref, NULL); + + reg_info->n_refs--; + + /* Unlink from the reg chain. If there is no prev, this is the + first of the list. If not, just join the next and prev. */ + if (prev) + { + DF_REF_NEXT_REG (prev) = next; + if (next) + DF_REF_PREV_REG (next) = prev; + } + else + { + reg_info->reg_chain = next; + if (next) + DF_REF_PREV_REG (next) = NULL; + } + + pool_free (problem_data->ref_pool, ref); + return next_ref; +} + + +/* Unlink REF from all def-use/use-def chains, etc. */ + +void +df_ref_remove (struct df *df, struct df_ref *ref) +{ + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; + if (DF_REF_REG_DEF_P (ref)) + { + if (DF_REF_FLAGS (ref) & DF_REF_ARTIFICIAL) + { + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, DF_REF_BB (ref)->index); + bb_info->artificial_defs + = df_ref_unlink (bb_info->artificial_defs, ref); + } + else + DF_INSN_UID_DEFS (df, DF_REF_INSN_UID (ref)) + = df_ref_unlink (DF_INSN_UID_DEFS (df, DF_REF_INSN_UID (ref)), ref); + + if (df->def_info.add_refs_inline) + DF_DEFS_SET (df, DF_REF_ID (ref), NULL); + } + else + { + if (DF_REF_FLAGS (ref) & DF_REF_ARTIFICIAL) + { + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, DF_REF_BB (ref)->index); + bb_info->artificial_uses + = df_ref_unlink (bb_info->artificial_uses, ref); + } + else + DF_INSN_UID_USES (df, DF_REF_INSN_UID (ref)) + = df_ref_unlink (DF_INSN_UID_USES (df, DF_REF_INSN_UID (ref)), ref); + + if (df->use_info.add_refs_inline) + DF_USES_SET (df, DF_REF_ID (ref), NULL); + } + + df_reg_chain_unlink (dflow, ref); +} + + +/* Create the insn record for INSN. If there was one there, zero it out. */ + +static struct df_insn_info * +df_insn_create_insn_record (struct dataflow *dflow, rtx insn) +{ + struct df *df = dflow->df; + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + + struct df_insn_info *insn_rec = DF_INSN_GET (df, insn); + if (!insn_rec) + { + insn_rec = pool_alloc (problem_data->insn_pool); + DF_INSN_SET (df, insn, insn_rec); + } + memset (insn_rec, 0, sizeof (struct df_insn_info)); + + return insn_rec; +} + + +/* Delete all of the refs information from INSN. */ + +void +df_insn_refs_delete (struct dataflow *dflow, rtx insn) +{ + struct df *df = dflow->df; + unsigned int uid = INSN_UID (insn); + struct df_insn_info *insn_info = NULL; + struct df_ref *ref; + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + + if (uid < df->insns_size) + insn_info = DF_INSN_UID_GET (df, uid); + + if (insn_info) + { + struct df_mw_hardreg *hardregs = insn_info->mw_hardregs; + + while (hardregs) + { + struct df_mw_hardreg *next_hr = hardregs->next; + struct df_link *link = hardregs->regs; + while (link) + { + struct df_link *next_l = link->next; + pool_free (problem_data->mw_link_pool, link); + link = next_l; + } + + pool_free (problem_data->mw_reg_pool, hardregs); + hardregs = next_hr; + } + + ref = insn_info->defs; + while (ref) + ref = df_reg_chain_unlink (dflow, ref); + + ref = insn_info->uses; + while (ref) + ref = df_reg_chain_unlink (dflow, ref); + + pool_free (problem_data->insn_pool, insn_info); + DF_INSN_SET (df, insn, NULL); + } +} + + +/* Delete all of the refs information from basic_block with BB_INDEX. */ + +void +df_bb_refs_delete (struct dataflow *dflow, int bb_index) +{ + struct df_ref *def; + struct df_ref *use; + + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, bb_index); + rtx insn; + basic_block bb = BASIC_BLOCK (bb_index); + FOR_BB_INSNS (bb, insn) + { + if (INSN_P (insn)) + { + /* Record defs within INSN. */ + df_insn_refs_delete (dflow, insn); + } + } + + /* Get rid of any artificial uses or defs. */ + if (bb_info) + { + def = bb_info->artificial_defs; + while (def) + def = df_reg_chain_unlink (dflow, def); + bb_info->artificial_defs = NULL; + use = bb_info->artificial_uses; + while (use) + use = df_reg_chain_unlink (dflow, use); + bb_info->artificial_uses = NULL; + } +} + + +/* Delete all of the refs information from BLOCKS. */ + +void +df_refs_delete (struct dataflow *dflow, bitmap blocks) +{ + bitmap_iterator bi; + unsigned int bb_index; + + EXECUTE_IF_SET_IN_BITMAP (blocks, 0, bb_index, bi) + { + df_bb_refs_delete (dflow, bb_index); + } +} + + +/* Take build ref table for either the uses or defs from the reg-use + or reg-def chains. */ + +void +df_reorganize_refs (struct df_ref_info *ref_info) +{ + unsigned int m = ref_info->regs_inited; + unsigned int regno; + unsigned int offset = 0; + unsigned int size = 0; + + if (ref_info->refs_organized) + return; + + if (ref_info->refs_size < ref_info->bitmap_size) + { + int new_size = ref_info->bitmap_size + ref_info->bitmap_size / 4; + df_grow_ref_info (ref_info, new_size); + } + + for (regno = 0; regno < m; regno++) + { + struct df_reg_info *reg_info = ref_info->regs[regno]; + int count = 0; + if (reg_info) + { + struct df_ref *ref = reg_info->reg_chain; + reg_info->begin = offset; + while (ref) + { + ref_info->refs[offset] = ref; + DF_REF_ID (ref) = offset++; + ref = DF_REF_NEXT_REG (ref); + count++; + size++; + } + reg_info->n_refs = count; + } + } + + /* The bitmap size is not decremented when refs are deleted. So + reset it now that we have squished out all of the empty + slots. */ + ref_info->bitmap_size = size; + ref_info->refs_organized = true; + ref_info->add_refs_inline = true; +} + + +/*---------------------------------------------------------------------------- + Hard core instruction scanning code. No external interfaces here, + just a lot of routines that look inside insns. +----------------------------------------------------------------------------*/ + +/* Create a ref and add it to the reg-def or reg-use chains. */ + +static struct df_ref * +df_ref_create_structure (struct dataflow *dflow, rtx reg, rtx *loc, + basic_block bb, rtx insn, + enum df_ref_type ref_type, + enum df_ref_flags ref_flags) +{ + struct df_ref *this_ref; + struct df *df = dflow->df; + int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg); + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + + this_ref = pool_alloc (problem_data->ref_pool); + DF_REF_REG (this_ref) = reg; + DF_REF_REGNO (this_ref) = regno; + DF_REF_LOC (this_ref) = loc; + DF_REF_INSN (this_ref) = insn; + DF_REF_CHAIN (this_ref) = NULL; + DF_REF_TYPE (this_ref) = ref_type; + DF_REF_FLAGS (this_ref) = ref_flags; + DF_REF_DATA (this_ref) = NULL; + DF_REF_BB (this_ref) = bb; + + /* Link the ref into the reg_def and reg_use chains and keep a count + of the instances. */ + switch (ref_type) + { + case DF_REF_REG_DEF: + { + struct df_reg_info *reg_info = DF_REG_DEF_GET (df, regno); + reg_info->n_refs++; + + /* Add the ref to the reg_def chain. */ + df_reg_chain_create (reg_info, this_ref); + DF_REF_ID (this_ref) = df->def_info.bitmap_size; + if (df->def_info.add_refs_inline) + { + if (DF_DEFS_SIZE (df) >= df->def_info.refs_size) + { + int new_size = df->def_info.bitmap_size + + df->def_info.bitmap_size / 4; + df_grow_ref_info (&df->def_info, new_size); + } + /* Add the ref to the big array of defs. */ + DF_DEFS_SET (df, df->def_info.bitmap_size, this_ref); + df->def_info.refs_organized = false; + } + + df->def_info.bitmap_size++; + + if (DF_REF_FLAGS (this_ref) & DF_REF_ARTIFICIAL) + { + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, bb->index); + this_ref->next_ref = bb_info->artificial_defs; + bb_info->artificial_defs = this_ref; + } + else + { + this_ref->next_ref = DF_INSN_GET (df, insn)->defs; + DF_INSN_GET (df, insn)->defs = this_ref; + } + } + break; + + case DF_REF_REG_MEM_LOAD: + case DF_REF_REG_MEM_STORE: + case DF_REF_REG_USE: + { + struct df_reg_info *reg_info = DF_REG_USE_GET (df, regno); + reg_info->n_refs++; + + /* Add the ref to the reg_use chain. */ + df_reg_chain_create (reg_info, this_ref); + DF_REF_ID (this_ref) = df->use_info.bitmap_size; + if (df->use_info.add_refs_inline) + { + if (DF_USES_SIZE (df) >= df->use_info.refs_size) + { + int new_size = df->use_info.bitmap_size + + df->use_info.bitmap_size / 4; + df_grow_ref_info (&df->use_info, new_size); + } + /* Add the ref to the big array of defs. */ + DF_USES_SET (df, df->use_info.bitmap_size, this_ref); + df->use_info.refs_organized = false; + } + + df->use_info.bitmap_size++; + if (DF_REF_FLAGS (this_ref) & DF_REF_ARTIFICIAL) + { + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, bb->index); + this_ref->next_ref = bb_info->artificial_uses; + bb_info->artificial_uses = this_ref; + } + else + { + this_ref->next_ref = DF_INSN_GET (df, insn)->uses; + DF_INSN_GET (df, insn)->uses = this_ref; + } + } + break; + + default: + gcc_unreachable (); + + } + return this_ref; +} + + +/* Create new references of type DF_REF_TYPE for each part of register REG + at address LOC within INSN of BB. */ + +static void +df_ref_record (struct dataflow *dflow, rtx reg, rtx *loc, + basic_block bb, rtx insn, + enum df_ref_type ref_type, + enum df_ref_flags ref_flags, + bool record_live) +{ + struct df *df = dflow->df; + rtx oldreg = reg; + unsigned int regno; + + gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG); + + /* For the reg allocator we are interested in some SUBREG rtx's, but not + all. Notably only those representing a word extraction from a multi-word + reg. As written in the docu those should have the form + (subreg:SI (reg:M A) N), with size(SImode) > size(Mmode). + XXX Is that true? We could also use the global word_mode variable. */ + if ((dflow->flags & DF_SUBREGS) == 0 + && GET_CODE (reg) == SUBREG + && (GET_MODE_SIZE (GET_MODE (reg)) < GET_MODE_SIZE (word_mode) + || GET_MODE_SIZE (GET_MODE (reg)) + >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (reg))))) + { + loc = &SUBREG_REG (reg); + reg = *loc; + ref_flags |= DF_REF_STRIPPED; + } + + regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg); + if (regno < FIRST_PSEUDO_REGISTER) + { + unsigned int i; + unsigned int endregno; + struct df_mw_hardreg *hardreg = NULL; + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) dflow->problem_data; + + if (!(dflow->flags & DF_HARD_REGS)) + return; + + /* GET_MODE (reg) is correct here. We do not want to go into a SUBREG + for the mode, because we only want to add references to regs, which + are really referenced. E.g., a (subreg:SI (reg:DI 0) 0) does _not_ + reference the whole reg 0 in DI mode (which would also include + reg 1, at least, if 0 and 1 are SImode registers). */ + endregno = hard_regno_nregs[regno][GET_MODE (reg)]; + if (GET_CODE (reg) == SUBREG) + regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)), + SUBREG_BYTE (reg), GET_MODE (reg)); + endregno += regno; + + /* If this is a multiword hardreg, we create some extra datastructures that + will enable us to easily build REG_DEAD and REG_UNUSED notes. */ + if ((endregno != regno + 1) && insn) + { + struct df_insn_info *insn_info = DF_INSN_GET (df, insn); + /* Sets to a subreg of a multiword register are partial. + Sets to a non-subreg of a multiword register are not. */ + if (GET_CODE (oldreg) == SUBREG) + ref_flags |= DF_REF_PARTIAL; + ref_flags |= DF_REF_MW_HARDREG; + hardreg = pool_alloc (problem_data->mw_reg_pool); + hardreg->next = insn_info->mw_hardregs; + insn_info->mw_hardregs = hardreg; + hardreg->type = ref_type; + hardreg->flags = ref_flags; + hardreg->mw_reg = reg; + hardreg->regs = NULL; + + } + + for (i = regno; i < endregno; i++) + { + struct df_ref *ref; + + /* Calls are handled at call site because regs_ever_live + doesn't include clobbered regs, only used ones. */ + if (ref_type == DF_REF_REG_DEF && record_live) + regs_ever_live[i] = 1; + else if ((ref_type == DF_REF_REG_USE + || ref_type == DF_REF_REG_MEM_STORE + || ref_type == DF_REF_REG_MEM_LOAD) + && ((ref_flags & DF_REF_ARTIFICIAL) == 0)) + { + /* Set regs_ever_live on uses of non-eliminable frame + pointers and arg pointers. */ + if (!(TEST_HARD_REG_BIT (elim_reg_set, regno) + && (regno == FRAME_POINTER_REGNUM + || regno == ARG_POINTER_REGNUM))) + regs_ever_live[i] = 1; + } + + ref = df_ref_create_structure (dflow, regno_reg_rtx[i], loc, + bb, insn, ref_type, ref_flags); + if (hardreg) + { + struct df_link *link = pool_alloc (problem_data->mw_link_pool); + + link->next = hardreg->regs; + link->ref = ref; + hardreg->regs = link; + } + } + } + else + { + df_ref_create_structure (dflow, reg, loc, + bb, insn, ref_type, ref_flags); + } +} + + +/* A set to a non-paradoxical SUBREG for which the number of word_mode units + covered by the outer mode is smaller than that covered by the inner mode, + is a read-modify-write operation. + This function returns true iff the SUBREG X is such a SUBREG. */ + +bool +df_read_modify_subreg_p (rtx x) +{ + unsigned int isize, osize; + if (GET_CODE (x) != SUBREG) + return false; + isize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))); + osize = GET_MODE_SIZE (GET_MODE (x)); + return (isize > osize && isize > UNITS_PER_WORD); +} + + +/* Process all the registers defined in the rtx, X. + Autoincrement/decrement definitions will be picked up by + df_uses_record. */ + +static void +df_def_record_1 (struct dataflow *dflow, rtx x, + basic_block bb, rtx insn, + enum df_ref_flags flags, bool record_live) +{ + rtx *loc; + rtx dst; + bool dst_in_strict_lowpart = false; + + /* 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; + + /* It is legal to have a set destination be a parallel. */ + if (GET_CODE (dst) == PARALLEL) + { + int i; + + for (i = XVECLEN (dst, 0) - 1; i >= 0; i--) + { + rtx temp = XVECEXP (dst, 0, i); + if (GET_CODE (temp) == EXPR_LIST || GET_CODE (temp) == CLOBBER + || GET_CODE (temp) == SET) + df_def_record_1 (dflow, temp, bb, insn, + GET_CODE (temp) == CLOBBER + ? flags | DF_REF_MUST_CLOBBER : flags, + record_live); + } + return; + } + + /* Maybe, we should flag the use of STRICT_LOW_PART somehow. It might + be handy for the reg allocator. */ + while (GET_CODE (dst) == STRICT_LOW_PART + || GET_CODE (dst) == ZERO_EXTRACT + || df_read_modify_subreg_p (dst)) + { +#if 0 + /* Strict low part always contains SUBREG, but we do not want to make + it appear outside, as whole register is always considered. */ + if (GET_CODE (dst) == STRICT_LOW_PART) + { + loc = &XEXP (dst, 0); + dst = *loc; + } +#endif + loc = &XEXP (dst, 0); + if (GET_CODE (dst) == STRICT_LOW_PART) + dst_in_strict_lowpart = true; + dst = *loc; + flags |= DF_REF_READ_WRITE; + + } + + /* Sets to a subreg of a single word register are partial sets if + they are wrapped in a strict lowpart, and not partial otherwise. + */ + if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)) + && dst_in_strict_lowpart) + flags |= DF_REF_PARTIAL; + + if (REG_P (dst) + || (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))) + df_ref_record (dflow, dst, loc, bb, insn, + DF_REF_REG_DEF, flags, record_live); +} + + +/* Process all the registers defined in the pattern rtx, X. */ + +static void +df_defs_record (struct dataflow *dflow, rtx x, basic_block bb, rtx insn) +{ + RTX_CODE code = GET_CODE (x); + + if (code == SET || code == CLOBBER) + { + /* Mark the single def within the pattern. */ + df_def_record_1 (dflow, x, bb, insn, + code == CLOBBER ? DF_REF_MUST_CLOBBER : 0, true); + } + else if (code == COND_EXEC) + { + df_defs_record (dflow, COND_EXEC_CODE (x), bb, insn); + } + else if (code == PARALLEL) + { + int i; + + /* Mark the multiple defs within the pattern. */ + for (i = XVECLEN (x, 0) - 1; i >= 0; i--) + df_defs_record (dflow, XVECEXP (x, 0, i), bb, insn); + } +} + + +/* Process all the registers used in the rtx at address LOC. */ + +static void +df_uses_record (struct dataflow *dflow, rtx *loc, enum df_ref_type ref_type, + basic_block bb, rtx insn, enum df_ref_flags flags) +{ + RTX_CODE code; + rtx x; + retry: + x = *loc; + if (!x) + return; + code = GET_CODE (x); + switch (code) + { + case LABEL_REF: + case SYMBOL_REF: + case CONST_INT: + case CONST: + case CONST_DOUBLE: + case CONST_VECTOR: + case PC: + case CC0: + case ADDR_VEC: + case ADDR_DIFF_VEC: + return; + + case CLOBBER: + /* If we are clobbering a MEM, mark any registers inside the address + as being used. */ + if (MEM_P (XEXP (x, 0))) + df_uses_record (dflow, &XEXP (XEXP (x, 0), 0), + DF_REF_REG_MEM_STORE, bb, insn, flags); + + /* If we're clobbering a REG then we have a def so ignore. */ + return; + + case MEM: + df_uses_record (dflow, &XEXP (x, 0), DF_REF_REG_MEM_LOAD, bb, insn, + flags & DF_REF_IN_NOTE); + return; + + case SUBREG: + /* While we're here, optimize this case. */ + flags |= DF_REF_PARTIAL; + /* In case the SUBREG is not of a REG, do not optimize. */ + if (!REG_P (SUBREG_REG (x))) + { + loc = &SUBREG_REG (x); + df_uses_record (dflow, loc, ref_type, bb, insn, flags); + return; + } + /* ... Fall through ... */ + + case REG: + df_ref_record (dflow, x, loc, bb, insn, ref_type, flags, true); + return; + + case SET: + { + rtx dst = SET_DEST (x); + gcc_assert (!(flags & DF_REF_IN_NOTE)); + df_uses_record (dflow, &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags); + + switch (GET_CODE (dst)) + { + case SUBREG: + if (df_read_modify_subreg_p (dst)) + { + df_uses_record (dflow, &SUBREG_REG (dst), + DF_REF_REG_USE, bb, + insn, flags | DF_REF_READ_WRITE); + break; + } + /* Fall through. */ + case REG: + case PARALLEL: + case SCRATCH: + case PC: + case CC0: + break; + case MEM: + df_uses_record (dflow, &XEXP (dst, 0), + DF_REF_REG_MEM_STORE, + bb, insn, flags); + break; + case STRICT_LOW_PART: + { + rtx *temp = &XEXP (dst, 0); + /* A strict_low_part uses the whole REG and not just the + SUBREG. */ + dst = XEXP (dst, 0); + df_uses_record (dflow, + (GET_CODE (dst) == SUBREG) + ? &SUBREG_REG (dst) : temp, + DF_REF_REG_USE, bb, + insn, DF_REF_READ_WRITE); + } + break; + case ZERO_EXTRACT: + case SIGN_EXTRACT: + df_uses_record (dflow, &XEXP (dst, 0), + DF_REF_REG_USE, bb, insn, + DF_REF_READ_WRITE); + df_uses_record (dflow, &XEXP (dst, 1), + DF_REF_REG_USE, bb, insn, flags); + df_uses_record (dflow, &XEXP (dst, 2), + DF_REF_REG_USE, bb, insn, flags); + dst = XEXP (dst, 0); + break; + default: + gcc_unreachable (); + } + return; + } + + case RETURN: + break; + + case ASM_OPERANDS: + case UNSPEC_VOLATILE: + case TRAP_IF: + case ASM_INPUT: + { + /* Traditional and volatile asm instructions must be + considered to use and clobber all hard registers, all + pseudo-registers and all of memory. So must TRAP_IF and + UNSPEC_VOLATILE operations. + + Consider for instance a volatile asm that changes the fpu + rounding mode. An insn should not be moved across this + even if it only uses pseudo-regs because it might give an + incorrectly rounded result. + + However, flow.c's liveness computation did *not* do this, + giving the reasoning as " ?!? Unfortunately, marking all + hard registers as live causes massive problems for the + register allocator and marking all pseudos as live creates + mountains of uninitialized variable warnings." + + In order to maintain the status quo with regard to liveness + and uses, we do what flow.c did and just mark any regs we + can find in ASM_OPERANDS as used. Later on, when liveness + is computed, asm insns are scanned and regs_asm_clobbered + is filled out. + + For all ASM_OPERANDS, we must traverse the vector of input + operands. We can not just fall through here since then we + would be confused by the ASM_INPUT rtx inside ASM_OPERANDS, + which do not indicate traditional asms unlike their normal + usage. */ + if (code == ASM_OPERANDS) + { + int j; + + for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++) + df_uses_record (dflow, &ASM_OPERANDS_INPUT (x, j), + DF_REF_REG_USE, bb, insn, flags); + return; + } + break; + } + + case PRE_DEC: + case POST_DEC: + case PRE_INC: + case POST_INC: + case PRE_MODIFY: + case POST_MODIFY: + /* Catch the def of the register being modified. */ + flags |= DF_REF_READ_WRITE; + df_ref_record (dflow, XEXP (x, 0), &XEXP (x, 0), bb, insn, + DF_REF_REG_DEF, flags, true); + + /* ... Fall through to handle uses ... */ + + default: + break; + } + + /* Recursively scan the operands of this expression. */ + { + const char *fmt = GET_RTX_FORMAT (code); + int i; + + for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) + { + if (fmt[i] == 'e') + { + /* Tail recursive case: save a function call level. */ + if (i == 0) + { + loc = &XEXP (x, 0); + goto retry; + } + df_uses_record (dflow, &XEXP (x, i), ref_type, bb, insn, flags); + } + else if (fmt[i] == 'E') + { + int j; + for (j = 0; j < XVECLEN (x, i); j++) + df_uses_record (dflow, &XVECEXP (x, i, j), ref_type, + bb, insn, flags); + } + } + } +} + +/* Return true if *LOC contains an asm. */ + +static int +df_insn_contains_asm_1 (rtx *loc, void *data ATTRIBUTE_UNUSED) +{ + if ( !*loc) + return 0; + if (GET_CODE (*loc) == ASM_OPERANDS) + return 1; + return 0; +} + + +/* Return true if INSN contains an ASM. */ + +static int +df_insn_contains_asm (rtx insn) +{ + return for_each_rtx (&insn, df_insn_contains_asm_1, NULL); +} + + + +/* Record all the refs for DF within INSN of basic block BB. */ + +static void +df_insn_refs_record (struct dataflow *dflow, basic_block bb, rtx insn) +{ + struct df *df = dflow->df; + int i; + + if (INSN_P (insn)) + { + rtx note; + + if (df_insn_contains_asm (insn)) + DF_INSN_CONTAINS_ASM (df, insn) = true; + + /* Record register defs. */ + df_defs_record (dflow, PATTERN (insn), bb, insn); + + if (dflow->flags & DF_EQUIV_NOTES) + for (note = REG_NOTES (insn); note; + note = XEXP (note, 1)) + { + switch (REG_NOTE_KIND (note)) + { + case REG_EQUIV: + case REG_EQUAL: + df_uses_record (dflow, &XEXP (note, 0), DF_REF_REG_USE, + bb, insn, DF_REF_IN_NOTE); + default: + break; + } + } + + if (CALL_P (insn)) + { + rtx note; + + /* Record the registers used to pass arguments, and explicitly + noted as clobbered. */ + for (note = CALL_INSN_FUNCTION_USAGE (insn); note; + note = XEXP (note, 1)) + { + if (GET_CODE (XEXP (note, 0)) == USE) + df_uses_record (dflow, &XEXP (XEXP (note, 0), 0), + DF_REF_REG_USE, + bb, insn, 0); + else if (GET_CODE (XEXP (note, 0)) == CLOBBER) + { + df_defs_record (dflow, XEXP (note, 0), bb, insn); + if (REG_P (XEXP (XEXP (note, 0), 0))) + { + rtx reg = XEXP (XEXP (note, 0), 0); + int regno_last; + int regno_first; + int i; + + regno_last = regno_first = REGNO (reg); + if (regno_first < FIRST_PSEUDO_REGISTER) + regno_last + += hard_regno_nregs[regno_first][GET_MODE (reg)] - 1; + for (i = regno_first; i <= regno_last; i++) + regs_ever_live[i] = 1; + } + } + } + + /* The stack ptr is used (honorarily) by a CALL insn. */ + df_uses_record (dflow, ®no_reg_rtx[STACK_POINTER_REGNUM], + DF_REF_REG_USE, bb, insn, + 0); + + if (dflow->flags & DF_HARD_REGS) + { + bitmap_iterator bi; + unsigned int ui; + /* 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_uses_record (dflow, ®no_reg_rtx[i], + DF_REF_REG_USE, bb, insn, + 0); + EXECUTE_IF_SET_IN_BITMAP (df_invalidated_by_call, 0, ui, bi) + df_ref_record (dflow, regno_reg_rtx[ui], ®no_reg_rtx[ui], bb, + insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER, false); + } + } + + /* Record the register uses. */ + df_uses_record (dflow, &PATTERN (insn), + DF_REF_REG_USE, bb, insn, 0); + + } +} + +static bool +df_has_eh_preds (basic_block bb) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, bb->preds) + { + if (e->flags & EDGE_EH) + return true; + } + return false; +} + +/* Record all the refs within the basic block BB. */ + +static void +df_bb_refs_record (struct dataflow *dflow, basic_block bb) +{ + struct df *df = dflow->df; + rtx insn; + int luid = 0; + struct df_scan_bb_info *bb_info = df_scan_get_bb_info (dflow, bb->index); + bitmap artificial_uses_at_bottom = NULL; + + if (dflow->flags & DF_HARD_REGS) + artificial_uses_at_bottom = BITMAP_ALLOC (NULL); + + /* Need to make sure that there is a record in the basic block info. */ + if (!bb_info) + { + bb_info = (struct df_scan_bb_info *) pool_alloc (dflow->block_pool); + df_scan_set_bb_info (dflow, bb->index, bb_info); + bb_info->artificial_defs = NULL; + bb_info->artificial_uses = NULL; + } + + /* Scan the block an insn at a time from beginning to end. */ + FOR_BB_INSNS (bb, insn) + { + df_insn_create_insn_record (dflow, insn); + if (INSN_P (insn)) + { + /* Record defs within INSN. */ + DF_INSN_LUID (df, insn) = luid++; + df_insn_refs_record (dflow, bb, insn); + } + DF_INSN_LUID (df, insn) = luid; + } + +#ifdef EH_RETURN_DATA_REGNO + if ((dflow->flags & DF_HARD_REGS) + && df_has_eh_preds (bb)) + { + unsigned int i; + /* Mark the registers that will contain data for the handler. */ + for (i = 0; ; ++i) + { + unsigned regno = EH_RETURN_DATA_REGNO (i); + if (regno == INVALID_REGNUM) + break; + df_ref_record (dflow, regno_reg_rtx[regno], ®no_reg_rtx[regno], + bb, NULL, + DF_REF_REG_DEF, DF_REF_ARTIFICIAL | DF_REF_AT_TOP, + false); + } + } +#endif + + + if ((dflow->flags & DF_HARD_REGS) + && df_has_eh_preds (bb)) + { +#ifdef EH_USES + unsigned int i; + /* This code is putting in a 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 the 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_uses_record (dflow, ®no_reg_rtx[i], + DF_REF_REG_USE, bb, NULL, + DF_REF_ARTIFICIAL | DF_REF_AT_TOP); +#endif + + /* The following code (down thru the arg_pointer setting APPEARS + to be necessary because there is nothing that actually + describes what the exception handling code may actually need + to keep alive. */ + if (reload_completed) + { + if (frame_pointer_needed) + { + bitmap_set_bit (artificial_uses_at_bottom, FRAME_POINTER_REGNUM); +#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM + bitmap_set_bit (artificial_uses_at_bottom, HARD_FRAME_POINTER_REGNUM); +#endif + } +#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM + if (fixed_regs[ARG_POINTER_REGNUM]) + bitmap_set_bit (artificial_uses_at_bottom, ARG_POINTER_REGNUM); +#endif + } + } + + if ((dflow->flags & DF_HARD_REGS) + && bb->index >= NUM_FIXED_BLOCKS) + { + /* Before reload, there are a few registers that must be forced + live everywhere -- which might not already be the case for + blocks within infinite loops. */ + if (!reload_completed) + { + + /* Any reference to any pseudo before reload is a potential + reference of the frame pointer. */ + bitmap_set_bit (artificial_uses_at_bottom, FRAME_POINTER_REGNUM); + +#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM + /* Pseudos with argument area equivalences may require + reloading via the argument pointer. */ + if (fixed_regs[ARG_POINTER_REGNUM]) + bitmap_set_bit (artificial_uses_at_bottom, ARG_POINTER_REGNUM); +#endif + + /* Any constant, or pseudo with constant equivalences, may + require reloading from memory using the pic register. */ + if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM + && fixed_regs[PIC_OFFSET_TABLE_REGNUM]) + bitmap_set_bit (artificial_uses_at_bottom, PIC_OFFSET_TABLE_REGNUM); + } + /* The all-important stack pointer must always be live. */ + bitmap_set_bit (artificial_uses_at_bottom, STACK_POINTER_REGNUM); + } + + if (dflow->flags & DF_HARD_REGS) + { + bitmap_iterator bi; + unsigned int regno; + + EXECUTE_IF_SET_IN_BITMAP (artificial_uses_at_bottom, 0, regno, bi) + { + df_uses_record (dflow, ®no_reg_rtx[regno], + DF_REF_REG_USE, bb, NULL, DF_REF_ARTIFICIAL); + } + + BITMAP_FREE (artificial_uses_at_bottom); + } +} + + +/* Record all the refs in the basic blocks specified by BLOCKS. */ + +static void +df_refs_record (struct dataflow *dflow, bitmap blocks) +{ + unsigned int bb_index; + bitmap_iterator bi; + + EXECUTE_IF_SET_IN_BITMAP (blocks, 0, bb_index, bi) + { + basic_block bb = BASIC_BLOCK (bb_index); + df_bb_refs_record (dflow, bb); + } + + if (bitmap_bit_p (blocks, EXIT_BLOCK)) + df_record_exit_block_uses (dflow); + + if (bitmap_bit_p (blocks, ENTRY_BLOCK)) + df_record_entry_block_defs (dflow); +} + + +/*---------------------------------------------------------------------------- + Specialized hard register scanning functions. +----------------------------------------------------------------------------*/ + +/* Mark a register in SET. Hard registers in large modes get all + of their component registers set as well. */ + +static void +df_mark_reg (rtx reg, void *vset) +{ + bitmap set = (bitmap) vset; + int regno = REGNO (reg); + + gcc_assert (GET_MODE (reg) != BLKmode); + + bitmap_set_bit (set, regno); + if (regno < FIRST_PSEUDO_REGISTER) + { + int n = hard_regno_nregs[regno][GET_MODE (reg)]; + while (--n > 0) + bitmap_set_bit (set, regno + n); + } +} + + +/* Record the (conservative) set of hard registers that are defined on + entry to the function. */ + +static void +df_record_entry_block_defs (struct dataflow *dflow) +{ + unsigned int i; + bitmap_iterator bi; + rtx r; + struct df *df = dflow->df; + + bitmap_clear (df->entry_block_defs); + + if (!(dflow->flags & DF_HARD_REGS)) + return; + + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + { + if (FUNCTION_ARG_REGNO_P (i)) +#ifdef INCOMING_REGNO + bitmap_set_bit (df->entry_block_defs, INCOMING_REGNO (i)); +#else + bitmap_set_bit (df->entry_block_defs, i); +#endif + } + + /* Once the prologue has been generated, all of these registers + should just show up in the first regular block. */ + if (HAVE_prologue && epilogue_completed) + { + /* Defs for the callee saved registers are inserted so that the + pushes have some defining location. */ + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + if ((call_used_regs[i] == 0) && (regs_ever_live[i])) + bitmap_set_bit (df->entry_block_defs, i); + } + else + { + /* The always important stack pointer. */ + bitmap_set_bit (df->entry_block_defs, STACK_POINTER_REGNUM); + +#ifdef INCOMING_RETURN_ADDR_RTX + if (REG_P (INCOMING_RETURN_ADDR_RTX)) + bitmap_set_bit (df->entry_block_defs, REGNO (INCOMING_RETURN_ADDR_RTX)); +#endif + + /* 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. */ +#ifdef STATIC_CHAIN_INCOMING_REGNUM + bitmap_set_bit (df->entry_block_defs, STATIC_CHAIN_INCOMING_REGNUM); +#else +#ifdef STATIC_CHAIN_REGNUM + bitmap_set_bit (df->entry_block_defs, STATIC_CHAIN_REGNUM); +#endif +#endif + + r = TARGET_STRUCT_VALUE_RTX (current_function_decl, true); + if (r && REG_P (r)) + bitmap_set_bit (df->entry_block_defs, REGNO (r)); + } + + if ((!reload_completed) || frame_pointer_needed) + { + /* Any reference to any pseudo before reload is a potential + reference of the frame pointer. */ + bitmap_set_bit (df->entry_block_defs, FRAME_POINTER_REGNUM); +#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM + /* If they are different, also mark the hard frame pointer as live. */ + if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM)) + bitmap_set_bit (df->entry_block_defs, HARD_FRAME_POINTER_REGNUM); +#endif + } + + /* 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 (df->entry_block_defs, i); + } +#endif + +#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM + /* Pseudos with argument area equivalences may require + reloading via the argument pointer. */ + if (fixed_regs[ARG_POINTER_REGNUM]) + bitmap_set_bit (df->entry_block_defs, ARG_POINTER_REGNUM); +#endif + +#ifdef PIC_OFFSET_TABLE_REGNUM + /* Any constant, or pseudo with constant equivalences, may + require reloading from memory using the pic register. */ + if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM + && fixed_regs[PIC_OFFSET_TABLE_REGNUM]) + bitmap_set_bit (df->entry_block_defs, PIC_OFFSET_TABLE_REGNUM); +#endif + } + + targetm.live_on_entry (df->entry_block_defs); + + EXECUTE_IF_SET_IN_BITMAP (df->entry_block_defs, 0, i, bi) + { + df_ref_record (dflow, regno_reg_rtx[i], ®no_reg_rtx[i], + ENTRY_BLOCK_PTR, NULL, + DF_REF_REG_DEF, DF_REF_ARTIFICIAL , false); + } +} + + +/* Record the set of hard registers that are used in the exit block. */ + +static void +df_record_exit_block_uses (struct dataflow *dflow) +{ + unsigned int i; + bitmap_iterator bi; + struct df *df = dflow->df; + + bitmap_clear (df->exit_block_uses); + + if (!(dflow->flags & DF_HARD_REGS)) + return; + + /* If exiting needs the right stack value, consider the stack + pointer live at the end of the function. */ + if ((HAVE_epilogue && epilogue_completed) + || !EXIT_IGNORE_STACK + || (!FRAME_POINTER_REQUIRED + && !current_function_calls_alloca + && flag_omit_frame_pointer) + || current_function_sp_is_unchanging) + { + bitmap_set_bit (df->exit_block_uses, STACK_POINTER_REGNUM); + } + + /* Mark the frame pointer if needed at the end of the function. + If we end up eliminating it, it will be removed from the live + list of each basic block by reload. */ + + if ((!reload_completed) || frame_pointer_needed) + { + bitmap_set_bit (df->exit_block_uses, FRAME_POINTER_REGNUM); +#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM + /* If they are different, also mark the hard frame pointer as live. */ + if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM)) + bitmap_set_bit (df->exit_block_uses, HARD_FRAME_POINTER_REGNUM); +#endif + } + +#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED + /* Many architectures have a GP register even without flag_pic. + Assume the pic register is not in use, or will be handled by + other means, if it is not fixed. */ + if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM + && fixed_regs[PIC_OFFSET_TABLE_REGNUM]) + bitmap_set_bit (df->exit_block_uses, PIC_OFFSET_TABLE_REGNUM); +#endif + + /* Mark all global registers, and all registers used by the + epilogue as being live at the end of the function since they + may be referenced by our caller. */ + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + if (global_regs[i] || EPILOGUE_USES (i)) + bitmap_set_bit (df->exit_block_uses, i); + + if (HAVE_epilogue && epilogue_completed) + { + /* Mark all call-saved registers that we actually used. */ + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + if (regs_ever_live[i] && !LOCAL_REGNO (i) + && !TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) + bitmap_set_bit (df->exit_block_uses, i); + } + +#ifdef EH_RETURN_DATA_REGNO + /* Mark the registers that will contain data for the handler. */ + if (reload_completed && current_function_calls_eh_return) + for (i = 0; ; ++i) + { + unsigned regno = EH_RETURN_DATA_REGNO (i); + if (regno == INVALID_REGNUM) + break; + bitmap_set_bit (df->exit_block_uses, regno); + } +#endif + +#ifdef EH_RETURN_STACKADJ_RTX + if ((!HAVE_epilogue || ! epilogue_completed) + && current_function_calls_eh_return) + { + rtx tmp = EH_RETURN_STACKADJ_RTX; + if (tmp && REG_P (tmp)) + df_mark_reg (tmp, df->exit_block_uses); + } +#endif + +#ifdef EH_RETURN_HANDLER_RTX + if ((!HAVE_epilogue || ! epilogue_completed) + && current_function_calls_eh_return) + { + rtx tmp = EH_RETURN_HANDLER_RTX; + if (tmp && REG_P (tmp)) + df_mark_reg (tmp, df->exit_block_uses); + } +#endif + + /* Mark function return value. */ + diddle_return_value (df_mark_reg, (void*) df->exit_block_uses); + + if (dflow->flags & DF_HARD_REGS) + EXECUTE_IF_SET_IN_BITMAP (df->exit_block_uses, 0, i, bi) + df_uses_record (dflow, ®no_reg_rtx[i], + DF_REF_REG_USE, EXIT_BLOCK_PTR, NULL, + DF_REF_ARTIFICIAL); +} + +static bool initialized = false; + +/* Initialize some platform specific structures. */ + +void +df_hard_reg_init (void) +{ + int i; +#ifdef ELIMINABLE_REGS + static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS; +#endif + /* After reload, some ports add certain bits to regs_ever_live so + this cannot be reset. */ + + if (!reload_completed) + memset (regs_ever_live, 0, sizeof (regs_ever_live)); + + 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); + +#ifdef ELIMINABLE_REGS + for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++) + SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from); +#else + 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; +} |