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