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

/* Scanning of rtl for dataflow analysis.
   Copyright (C) 2007-2019 Free Software Foundation, Inc.
   Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */


#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "rtl.h"
#include "predict.h"
#include "df.h"
#include "regs.h"


struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs;

/*----------------------------------------------------------------------------
   REG_N_SETS and REG_N_REFS.
   ----------------------------------------------------------------------------*/

/* If a pass need to change these values in some magical way or the
   pass needs to have accurate values for these and is not using
   incremental df scanning, then it should use REG_N_SETS and
   REG_N_USES.  If the pass is doing incremental scanning then it
   should be getting the info from DF_REG_DEF_COUNT and
   DF_REG_USE_COUNT.  */

void
regstat_init_n_sets_and_refs (void)
{
  unsigned int i;
  unsigned int max_regno = max_reg_num ();

  timevar_push (TV_REG_STATS);
  df_grow_reg_info ();
  gcc_assert (!regstat_n_sets_and_refs);

  regstat_n_sets_and_refs = XNEWVEC (struct regstat_n_sets_and_refs_t, max_regno);

  if (MAY_HAVE_DEBUG_BIND_INSNS)
    for (i = 0; i < max_regno; i++)
      {
	int use_count;
	df_ref use;

	use_count = DF_REG_USE_COUNT (i);
	for (use = DF_REG_USE_CHAIN (i); use; use = DF_REF_NEXT_REG (use))
	  if (DF_REF_INSN_INFO (use) && DEBUG_INSN_P (DF_REF_INSN (use)))
	    use_count--;


	SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
	SET_REG_N_REFS (i, use_count + REG_N_SETS (i));
      }
  else
    for (i = 0; i < max_regno; i++)
      {
	SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
	SET_REG_N_REFS (i, DF_REG_USE_COUNT (i) + REG_N_SETS (i));
      }
  timevar_pop (TV_REG_STATS);

}


/* Free the array that holds the REG_N_SETS and REG_N_REFS.  */

void
regstat_free_n_sets_and_refs (void)
{
  gcc_assert (regstat_n_sets_and_refs);
  free (regstat_n_sets_and_refs);
  regstat_n_sets_and_refs = NULL;
}


/*----------------------------------------------------------------------------
   REGISTER INFORMATION

   Process REG_N_DEATHS, REG_N_CALLS_CROSSED, and REG_BASIC_BLOCK.

   ----------------------------------------------------------------------------*/

static bitmap setjmp_crosses;
struct reg_info_t *reg_info_p;

/* The number allocated elements of reg_info_p.  */
size_t reg_info_p_size;

/* Compute register info: lifetime, bb, and number of defs and uses
   for basic block BB.  LIVE is a scratch bitvector used here.  */

static void
regstat_bb_compute_ri (basic_block bb, bitmap live)
{
  rtx_insn *insn;
  df_ref def, use;
  bitmap_iterator bi;
  unsigned int regno;

  bitmap_copy (live, df_get_live_out (bb));

  /* Process the regs live at the end of the block.  Mark them as
     not local to any one basic block.  */
  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
    REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;

  /* Process the artificial defs and uses at the bottom of the block
     to begin processing.  */
  FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
    if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
      bitmap_clear_bit (live, DF_REF_REGNO (def));

  FOR_EACH_ARTIFICIAL_USE (use, bb->index)
    if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
      {
	regno = DF_REF_REGNO (use);
	bitmap_set_bit (live, regno);
      }

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
      bitmap_iterator bi;
      rtx link;

      if (!NONDEBUG_INSN_P (insn))
	continue;

      link = REG_NOTES (insn);
      while (link)
	{
	  if (REG_NOTE_KIND (link) == REG_DEAD)
	    REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
	  link = XEXP (link, 1);
	}

      /* Process the defs.  */
      if (CALL_P (insn))
	{
	  bool set_jump = (find_reg_note (insn, REG_SETJMP, NULL) != NULL);
	  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
	    {
	      REG_N_CALLS_CROSSED (regno)++;

	      /* We have a problem with any pseudoreg that lives
		 across the setjmp.  ANSI says that if a user variable
		 does not change in value between the setjmp and the
		 longjmp, then the longjmp preserves it.  This
		 includes longjmp from a place where the pseudo
		 appears dead.  (In principle, the value still exists
		 if it is in scope.)  If the pseudo goes in a hard
		 reg, some other value may occupy that hard reg where
		 this pseudo is dead, thus clobbering the pseudo.
		 Conclusion: such a pseudo must not go in a hard
		 reg.  */
	      if (set_jump)
		bitmap_set_bit (setjmp_crosses, regno);
	    }
	}

      /* All of the defs except the return value are some sort of
	 clobber.  This code is for the return.  */
      FOR_EACH_INSN_INFO_DEF (def, insn_info)
	{
	  if ((!CALL_P (insn))
	      || (!(DF_REF_FLAGS (def)
		    & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
	    {
	      unsigned int dregno = DF_REF_REGNO (def);

	      /* Kill this register if it is not a subreg store or
		 conditional store.
		 ??? This means that any partial store is live from
		 the last use in a basic block to the start of this
		 basic block.  */
	      if (!(DF_REF_FLAGS (def)
		    & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
		bitmap_clear_bit (live, dregno);

	      if (dregno >= FIRST_PSEUDO_REGISTER)
		{
		  REG_FREQ (dregno) += REG_FREQ_FROM_BB (bb);
		  REG_FREQ (dregno) =
		    MIN (REG_FREQ (dregno), REG_FREQ_MAX);

		  if (REG_BASIC_BLOCK (dregno) == REG_BLOCK_UNKNOWN)
		    REG_BASIC_BLOCK (dregno) = bb->index;
		  else if (REG_BASIC_BLOCK (dregno) != bb->index)
		    REG_BASIC_BLOCK (dregno) = REG_BLOCK_GLOBAL;
		}
	    }
	}

      FOR_EACH_INSN_INFO_USE (use, insn_info)
	{
	  unsigned int uregno = DF_REF_REGNO (use);

	  if (uregno >= FIRST_PSEUDO_REGISTER)
	    {
	      REG_FREQ (uregno) += REG_FREQ_FROM_BB (bb);
	      REG_FREQ (uregno) =
		MIN (REG_FREQ (uregno), REG_FREQ_MAX);

	      if (REG_BASIC_BLOCK (uregno) == REG_BLOCK_UNKNOWN)
		REG_BASIC_BLOCK (uregno) = bb->index;
	      else if (REG_BASIC_BLOCK (uregno) != bb->index)
		REG_BASIC_BLOCK (uregno) = REG_BLOCK_GLOBAL;
	    }
	}
    }
}


/* Compute register info: lifetime, bb, and number of defs and uses.  */
void
regstat_compute_ri (void)
{
  basic_block bb;
  bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
  unsigned int regno;
  bitmap_iterator bi;

  /* Initialize everything.  */

  gcc_assert (!reg_info_p);

  timevar_push (TV_REG_STATS);
  setjmp_crosses = BITMAP_ALLOC (&df_bitmap_obstack);
  max_regno = max_reg_num ();
  reg_info_p_size = max_regno;
  reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);

  FOR_EACH_BB_FN (bb, cfun)
    {
      regstat_bb_compute_ri (bb, live);
    }

  BITMAP_FREE (live);

  /* See the setjmp comment in regstat_bb_compute_ri.  */
  EXECUTE_IF_SET_IN_BITMAP (setjmp_crosses, FIRST_PSEUDO_REGISTER, regno, bi)
    {
      REG_BASIC_BLOCK (regno) = REG_BLOCK_UNKNOWN;
    }

  timevar_pop (TV_REG_STATS);
}


/* Free all storage associated with the problem.  */

void
regstat_free_ri (void)
{
  gcc_assert (reg_info_p);
  reg_info_p_size = 0;
  free (reg_info_p);
  reg_info_p = NULL;

  BITMAP_FREE (setjmp_crosses);
}


/* Return a bitmap containing the set of registers that cross a setjmp.
   The client should not change or delete this bitmap.  */

bitmap
regstat_get_setjmp_crosses (void)
{
  return setjmp_crosses;
}

/*----------------------------------------------------------------------------
   Process REG_N_CALLS_CROSSED.

   This is used by sched_deps.  A good implementation of sched-deps
   would really process the blocks directly rather than going through
   lists of insns.  If it did this, it could use the exact regs that
   cross an individual call rather than using this info that merges
   the info for all calls.

   ----------------------------------------------------------------------------*/


/* Compute calls crossed for BB. Live is a scratch bitvector.  */

static void
regstat_bb_compute_calls_crossed (unsigned int bb_index, bitmap live)
{
  basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
  rtx_insn *insn;
  df_ref def, use;

  bitmap_copy (live, df_get_live_out (bb));

  /* Process the artificial defs and uses at the bottom of the block
     to begin processing.  */
  FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
    if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
      bitmap_clear_bit (live, DF_REF_REGNO (def));

  FOR_EACH_ARTIFICIAL_USE (use, bb_index)
    if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
      bitmap_set_bit (live, DF_REF_REGNO (use));

  FOR_BB_INSNS_REVERSE (bb, insn)
    {
      struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
      unsigned int regno;

      if (!NONDEBUG_INSN_P (insn))
	continue;

      /* Process the defs.  */
      if (CALL_P (insn))
	{
	  bitmap_iterator bi;
	  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
	    {
	      REG_N_CALLS_CROSSED (regno)++;
	    }
	}

      /* All of the defs except the return value are some sort of
	 clobber.  This code is for the return.  */
      FOR_EACH_INSN_INFO_DEF (def, insn_info)
	{
	  if ((!CALL_P (insn))
	      || (!(DF_REF_FLAGS (def) & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
	    {
	      /* Kill this register if it is not a subreg store or conditional store.  */
	      if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
		bitmap_clear_bit (live, DF_REF_REGNO (def));
	    }
	}

      FOR_EACH_INSN_INFO_USE (use, insn_info)
	bitmap_set_bit (live, DF_REF_REGNO (use));
    }
}


/* Compute register info: lifetime, bb, and number of defs and uses.  */
void
regstat_compute_calls_crossed (void)
{
  basic_block bb;
  bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);

  /* Initialize everything.  */
  gcc_assert (!reg_info_p);

  timevar_push (TV_REG_STATS);
  max_regno = max_reg_num ();
  reg_info_p_size = max_regno;
  reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);

  FOR_EACH_BB_FN (bb, cfun)
    {
      regstat_bb_compute_calls_crossed (bb->index, live);
    }

  BITMAP_FREE (live);
  timevar_pop (TV_REG_STATS);
}


/* Free all storage associated with the problem.  */

void
regstat_free_calls_crossed (void)
{
  gcc_assert (reg_info_p);
  reg_info_p_size = 0;
  free (reg_info_p);
  reg_info_p = NULL;
}

/* Dump the register info to FILE.  */

void
dump_reg_info (FILE *file)
{
  unsigned int i, max = max_reg_num ();
  if (reload_completed)
    return;

  if (reg_info_p_size < max)
    max = reg_info_p_size;

  fprintf (file, "%d registers.\n", max);
  for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
    {
      enum reg_class rclass, altclass;

      if (regstat_n_sets_and_refs)
	fprintf (file, "\nRegister %d used %d times",
		 i, REG_N_REFS (i));
      else if (df)
	fprintf (file, "\nRegister %d used %d times",
		 i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i));

      if (REG_BASIC_BLOCK (i) >= NUM_FIXED_BLOCKS)
	fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
      if (regstat_n_sets_and_refs)
	fprintf (file, "; set %d time%s", REG_N_SETS (i),
		 (REG_N_SETS (i) == 1) ? "" : "s");
      else if (df)
	fprintf (file, "; set %d time%s", DF_REG_DEF_COUNT (i),
		 (DF_REG_DEF_COUNT (i) == 1) ? "" : "s");
      if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
	fputs ("; user var", file);
      if (REG_N_DEATHS (i) != 1)
	fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
      if (REG_N_CALLS_CROSSED (i) == 1)
	fputs ("; crosses 1 call", file);
      else if (REG_N_CALLS_CROSSED (i))
	fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
      if (regno_reg_rtx[i] != NULL
	  && maybe_ne (PSEUDO_REGNO_BYTES (i), UNITS_PER_WORD))
	{
	  fprintf (file, "; ");
	  print_dec (PSEUDO_REGNO_BYTES (i), file, SIGNED);
	  fprintf (file, " bytes");
	}

      rclass = reg_preferred_class (i);
      altclass = reg_alternate_class (i);
      if (rclass != GENERAL_REGS || altclass != ALL_REGS)
	{
	  if (altclass == ALL_REGS || rclass == ALL_REGS)
	    fprintf (file, "; pref %s", reg_class_names[(int) rclass]);
	  else if (altclass == NO_REGS)
	    fprintf (file, "; %s or none", reg_class_names[(int) rclass]);
	  else
	    fprintf (file, "; pref %s, else %s",
		     reg_class_names[(int) rclass],
		     reg_class_names[(int) altclass]);
	}

      if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
	fputs ("; pointer", file);
      fputs (".\n", file);
    }
}
Commit	Line	Data
3072d30e	1	/* Scanning of rtl for dataflow analysis.
fbd26352	2	Copyright (C) 2007-2019 Free Software Foundation, Inc.
3072d30e	3	Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
8c4c00c1	9	Software Foundation; either version 3, or (at your option) any later
3072d30e	10	version.
	11
	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License
8c4c00c1	18	along with GCC; see the file COPYING3. If not see
8c4c00c1	19	<http://www.gnu.org/licenses/>. */
3072d30e	20
	21
	22	#include "config.h"
	23	#include "system.h"
	24	#include "coretypes.h"
9ef16211	25	#include "backend.h"
3072d30e	26	#include "rtl.h"
7c29e30e	27	#include "predict.h"
9ef16211	28	#include "df.h"
3072d30e	29	#include "regs.h"
3072d30e	30
3072d30e	31
3072d30e	32	struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs;
	33
	34	/*----------------------------------------------------------------------------
48e1416a	35	REG_N_SETS and REG_N_REFS.
3072d30e	36	----------------------------------------------------------------------------*/
3072d30e	37
851d9296	38	/* If a pass need to change these values in some magical way or the
3072d30e	39	pass needs to have accurate values for these and is not using
	40	incremental df scanning, then it should use REG_N_SETS and
	41	REG_N_USES. If the pass is doing incremental scanning then it
	42	should be getting the info from DF_REG_DEF_COUNT and
	43	DF_REG_USE_COUNT. */
	44
	45	void
	46	regstat_init_n_sets_and_refs (void)
	47	{
	48	unsigned int i;
	49	unsigned int max_regno = max_reg_num ();
	50
	51	timevar_push (TV_REG_STATS);
	52	df_grow_reg_info ();
	53	gcc_assert (!regstat_n_sets_and_refs);
	54
f7f3687c	55	regstat_n_sets_and_refs = XNEWVEC (struct regstat_n_sets_and_refs_t, max_regno);
3072d30e	56
c64f38bf	57	if (MAY_HAVE_DEBUG_BIND_INSNS)
9845d120	58	for (i = 0; i < max_regno; i++)
	59	{
	60	int use_count;
	61	df_ref use;
	62
	63	use_count = DF_REG_USE_COUNT (i);
	64	for (use = DF_REG_USE_CHAIN (i); use; use = DF_REF_NEXT_REG (use))
	65	if (DF_REF_INSN_INFO (use) && DEBUG_INSN_P (DF_REF_INSN (use)))
	66	use_count--;
	67
	68
	69	SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
	70	SET_REG_N_REFS (i, use_count + REG_N_SETS (i));
	71	}
	72	else
	73	for (i = 0; i < max_regno; i++)
	74	{
	75	SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
	76	SET_REG_N_REFS (i, DF_REG_USE_COUNT (i) + REG_N_SETS (i));
	77	}
3072d30e	78	timevar_pop (TV_REG_STATS);
	79
	80	}
	81
	82
	83	/* Free the array that holds the REG_N_SETS and REG_N_REFS. */
	84
	85	void
	86	regstat_free_n_sets_and_refs (void)
	87	{
	88	gcc_assert (regstat_n_sets_and_refs);
	89	free (regstat_n_sets_and_refs);
	90	regstat_n_sets_and_refs = NULL;
	91	}
	92
	93
	94	/*----------------------------------------------------------------------------
	95	REGISTER INFORMATION
	96
32305c37	97	Process REG_N_DEATHS, REG_N_CALLS_CROSSED, and REG_BASIC_BLOCK.
3072d30e	98
	99	----------------------------------------------------------------------------*/
	100
	101	static bitmap setjmp_crosses;
	102	struct reg_info_t *reg_info_p;
	103
	104	/* The number allocated elements of reg_info_p. */
	105	size_t reg_info_p_size;
	106
	107	/* Compute register info: lifetime, bb, and number of defs and uses
b662dace	108	for basic block BB. LIVE is a scratch bitvector used here. */
3072d30e	109
3072d30e	110	static void
b662dace	111	regstat_bb_compute_ri (basic_block bb, bitmap live)
3072d30e	112	{
8c35fb1b	113	rtx_insn *insn;
be10bb5a	114	df_ref def, use;
3072d30e	115	bitmap_iterator bi;
	116	unsigned int regno;
	117
	118	bitmap_copy (live, df_get_live_out (bb));
3072d30e	119
	120	/* Process the regs live at the end of the block. Mark them as
	121	not local to any one basic block. */
	122	EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
	123	REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
	124
	125	/* Process the artificial defs and uses at the bottom of the block
	126	to begin processing. */
b662dace	127	FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
f1c570a6	128	if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
f1c570a6	129	bitmap_clear_bit (live, DF_REF_REGNO (def));
3072d30e	130
b662dace	131	FOR_EACH_ARTIFICIAL_USE (use, bb->index)
f1c570a6	132	if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
	133	{
	134	regno = DF_REF_REGNO (use);
	135	bitmap_set_bit (live, regno);
f1c570a6	136	}
48e1416a	137
3072d30e	138	FOR_BB_INSNS_REVERSE (bb, insn)
3072d30e	139	{
be10bb5a	140	struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3072d30e	141	bitmap_iterator bi;
3072d30e	142	rtx link;
48e1416a	143
9845d120	144	if (!NONDEBUG_INSN_P (insn))
3072d30e	145	continue;
3072d30e	146
3072d30e	147	link = REG_NOTES (insn);
	148	while (link)
	149	{
	150	if (REG_NOTE_KIND (link) == REG_DEAD)
9af5ce0c	151	REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
3072d30e	152	link = XEXP (link, 1);
	153	}
	154
	155	/* Process the defs. */
	156	if (CALL_P (insn))
	157	{
3072d30e	158	bool set_jump = (find_reg_note (insn, REG_SETJMP, NULL) != NULL);
	159	EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
	160	{
	161	REG_N_CALLS_CROSSED (regno)++;
48e1416a	162
3072d30e	163	/* We have a problem with any pseudoreg that lives
	164	across the setjmp. ANSI says that if a user variable
	165	does not change in value between the setjmp and the
	166	longjmp, then the longjmp preserves it. This
	167	includes longjmp from a place where the pseudo
	168	appears dead. (In principle, the value still exists
	169	if it is in scope.) If the pseudo goes in a hard
	170	reg, some other value may occupy that hard reg where
	171	this pseudo is dead, thus clobbering the pseudo.
	172	Conclusion: such a pseudo must not go in a hard
	173	reg. */
	174	if (set_jump)
	175	bitmap_set_bit (setjmp_crosses, regno);
	176	}
	177	}
48e1416a	178
3072d30e	179	/* All of the defs except the return value are some sort of
3072d30e	180	clobber. This code is for the return. */
be10bb5a	181	FOR_EACH_INSN_INFO_DEF (def, insn_info)
3072d30e	182	{
3072d30e	183	if ((!CALL_P (insn))
b662dace	184	\|\| (!(DF_REF_FLAGS (def)
b662dace	185	& (DF_REF_MUST_CLOBBER \| DF_REF_MAY_CLOBBER))))
3072d30e	186	{
3072d30e	187	unsigned int dregno = DF_REF_REGNO (def);
48e1416a	188
b662dace	189	/* Kill this register if it is not a subreg store or
	190	conditional store.
	191	??? This means that any partial store is live from
	192	the last use in a basic block to the start of this
	193	basic block. */
	194	if (!(DF_REF_FLAGS (def)
	195	& (DF_REF_PARTIAL \| DF_REF_CONDITIONAL)))
	196	bitmap_clear_bit (live, dregno);
48e1416a	197
3072d30e	198	if (dregno >= FIRST_PSEUDO_REGISTER)
	199	{
	200	REG_FREQ (dregno) += REG_FREQ_FROM_BB (bb);
cb454387	201	REG_FREQ (dregno) =
	202	MIN (REG_FREQ (dregno), REG_FREQ_MAX);
	203
3072d30e	204	if (REG_BASIC_BLOCK (dregno) == REG_BLOCK_UNKNOWN)
	205	REG_BASIC_BLOCK (dregno) = bb->index;
	206	else if (REG_BASIC_BLOCK (dregno) != bb->index)
	207	REG_BASIC_BLOCK (dregno) = REG_BLOCK_GLOBAL;
	208	}
3072d30e	209	}
3072d30e	210	}
48e1416a	211
be10bb5a	212	FOR_EACH_INSN_INFO_USE (use, insn_info)
3072d30e	213	{
3072d30e	214	unsigned int uregno = DF_REF_REGNO (use);
	215
	216	if (uregno >= FIRST_PSEUDO_REGISTER)
	217	{
	218	REG_FREQ (uregno) += REG_FREQ_FROM_BB (bb);
cb454387	219	REG_FREQ (uregno) =
	220	MIN (REG_FREQ (uregno), REG_FREQ_MAX);
	221
3072d30e	222	if (REG_BASIC_BLOCK (uregno) == REG_BLOCK_UNKNOWN)
	223	REG_BASIC_BLOCK (uregno) = bb->index;
	224	else if (REG_BASIC_BLOCK (uregno) != bb->index)
	225	REG_BASIC_BLOCK (uregno) = REG_BLOCK_GLOBAL;
	226	}
3072d30e	227	}
3072d30e	228	}
3072d30e	229	}
	230
	231
	232	/* Compute register info: lifetime, bb, and number of defs and uses. */
	233	void
	234	regstat_compute_ri (void)
	235	{
	236	basic_block bb;
	237	bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
3072d30e	238	unsigned int regno;
	239	bitmap_iterator bi;
	240
	241	/* Initialize everything. */
	242
	243	gcc_assert (!reg_info_p);
	244
	245	timevar_push (TV_REG_STATS);
	246	setjmp_crosses = BITMAP_ALLOC (&df_bitmap_obstack);
	247	max_regno = max_reg_num ();
	248	reg_info_p_size = max_regno;
f7f3687c	249	reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
3072d30e	250
fc00614f	251	FOR_EACH_BB_FN (bb, cfun)
3072d30e	252	{
b662dace	253	regstat_bb_compute_ri (bb, live);
3072d30e	254	}
	255
	256	BITMAP_FREE (live);
3072d30e	257
957b2bdc	258	/* See the setjmp comment in regstat_bb_compute_ri. */
3072d30e	259	EXECUTE_IF_SET_IN_BITMAP (setjmp_crosses, FIRST_PSEUDO_REGISTER, regno, bi)
	260	{
	261	REG_BASIC_BLOCK (regno) = REG_BLOCK_UNKNOWN;
48e1416a	262	}
48e1416a	263
3072d30e	264	timevar_pop (TV_REG_STATS);
	265	}
	266
	267
	268	/* Free all storage associated with the problem. */
	269
	270	void
	271	regstat_free_ri (void)
	272	{
	273	gcc_assert (reg_info_p);
	274	reg_info_p_size = 0;
48e1416a	275	free (reg_info_p);
3072d30e	276	reg_info_p = NULL;
	277
	278	BITMAP_FREE (setjmp_crosses);
	279	}
	280
	281
48e1416a	282	/* Return a bitmap containing the set of registers that cross a setjmp.
3072d30e	283	The client should not change or delete this bitmap. */
	284
	285	bitmap
	286	regstat_get_setjmp_crosses (void)
	287	{
	288	return setjmp_crosses;
	289	}
	290
	291	/*----------------------------------------------------------------------------
48e1416a	292	Process REG_N_CALLS_CROSSED.
3072d30e	293
3072d30e	294	This is used by sched_deps. A good implementation of sched-deps
4a7e4fcc	295	would really process the blocks directly rather than going through
3072d30e	296	lists of insns. If it did this, it could use the exact regs that
	297	cross an individual call rather than using this info that merges
	298	the info for all calls.
	299
	300	----------------------------------------------------------------------------*/
	301
	302
	303
bef304b8	304	/* Compute calls crossed for BB. Live is a scratch bitvector. */
3072d30e	305
	306	static void
	307	regstat_bb_compute_calls_crossed (unsigned int bb_index, bitmap live)
	308	{
f5a6b05f	309	basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
8c35fb1b	310	rtx_insn *insn;
be10bb5a	311	df_ref def, use;
3072d30e	312
	313	bitmap_copy (live, df_get_live_out (bb));
	314
	315	/* Process the artificial defs and uses at the bottom of the block
	316	to begin processing. */
f1c570a6	317	FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
	318	if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
	319	bitmap_clear_bit (live, DF_REF_REGNO (def));
3072d30e	320
f1c570a6	321	FOR_EACH_ARTIFICIAL_USE (use, bb_index)
	322	if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
	323	bitmap_set_bit (live, DF_REF_REGNO (use));
48e1416a	324
3072d30e	325	FOR_BB_INSNS_REVERSE (bb, insn)
3072d30e	326	{
be10bb5a	327	struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3072d30e	328	unsigned int regno;
48e1416a	329
4ccd644f	330	if (!NONDEBUG_INSN_P (insn))
3072d30e	331	continue;
	332
	333	/* Process the defs. */
	334	if (CALL_P (insn))
	335	{
	336	bitmap_iterator bi;
	337	EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
a8587796	338	{
a8587796	339	REG_N_CALLS_CROSSED (regno)++;
a8587796	340	}
3072d30e	341	}
48e1416a	342
3072d30e	343	/* All of the defs except the return value are some sort of
3072d30e	344	clobber. This code is for the return. */
be10bb5a	345	FOR_EACH_INSN_INFO_DEF (def, insn_info)
3072d30e	346	{
3072d30e	347	if ((!CALL_P (insn))
	348	\|\| (!(DF_REF_FLAGS (def) & (DF_REF_MUST_CLOBBER \| DF_REF_MAY_CLOBBER))))
	349	{
	350	/* Kill this register if it is not a subreg store or conditional store. */
	351	if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL \| DF_REF_CONDITIONAL)))
	352	bitmap_clear_bit (live, DF_REF_REGNO (def));
	353	}
	354	}
48e1416a	355
be10bb5a	356	FOR_EACH_INSN_INFO_USE (use, insn_info)
be10bb5a	357	bitmap_set_bit (live, DF_REF_REGNO (use));
3072d30e	358	}
	359	}
	360
	361
	362	/* Compute register info: lifetime, bb, and number of defs and uses. */
	363	void
	364	regstat_compute_calls_crossed (void)
	365	{
	366	basic_block bb;
	367	bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
	368
	369	/* Initialize everything. */
	370	gcc_assert (!reg_info_p);
	371
	372	timevar_push (TV_REG_STATS);
	373	max_regno = max_reg_num ();
	374	reg_info_p_size = max_regno;
f7f3687c	375	reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
3072d30e	376
fc00614f	377	FOR_EACH_BB_FN (bb, cfun)
3072d30e	378	{
	379	regstat_bb_compute_calls_crossed (bb->index, live);
	380	}
	381
	382	BITMAP_FREE (live);
	383	timevar_pop (TV_REG_STATS);
	384	}
	385
	386
	387	/* Free all storage associated with the problem. */
	388
	389	void
	390	regstat_free_calls_crossed (void)
	391	{
	392	gcc_assert (reg_info_p);
	393	reg_info_p_size = 0;
48e1416a	394	free (reg_info_p);
3072d30e	395	reg_info_p = NULL;
	396	}
	397
4a020a8c	398	/* Dump the register info to FILE. */
	399
	400	void
	401	dump_reg_info (FILE *file)
	402	{
	403	unsigned int i, max = max_reg_num ();
	404	if (reload_completed)
	405	return;
	406
	407	if (reg_info_p_size < max)
	408	max = reg_info_p_size;
	409
	410	fprintf (file, "%d registers.\n", max);
	411	for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
	412	{
	413	enum reg_class rclass, altclass;
	414
	415	if (regstat_n_sets_and_refs)
b662dace	416	fprintf (file, "\nRegister %d used %d times",
b662dace	417	i, REG_N_REFS (i));
4a020a8c	418	else if (df)
b662dace	419	fprintf (file, "\nRegister %d used %d times",
b662dace	420	i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i));
4a020a8c	421
	422	if (REG_BASIC_BLOCK (i) >= NUM_FIXED_BLOCKS)
	423	fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
	424	if (regstat_n_sets_and_refs)
	425	fprintf (file, "; set %d time%s", REG_N_SETS (i),
	426	(REG_N_SETS (i) == 1) ? "" : "s");
	427	else if (df)
	428	fprintf (file, "; set %d time%s", DF_REG_DEF_COUNT (i),
	429	(DF_REG_DEF_COUNT (i) == 1) ? "" : "s");
	430	if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
	431	fputs ("; user var", file);
	432	if (REG_N_DEATHS (i) != 1)
	433	fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
	434	if (REG_N_CALLS_CROSSED (i) == 1)
	435	fputs ("; crosses 1 call", file);
	436	else if (REG_N_CALLS_CROSSED (i))
	437	fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
4a020a8c	438	if (regno_reg_rtx[i] != NULL
52acb7ae	439	&& maybe_ne (PSEUDO_REGNO_BYTES (i), UNITS_PER_WORD))
	440	{
	441	fprintf (file, "; ");
	442	print_dec (PSEUDO_REGNO_BYTES (i), file, SIGNED);
	443	fprintf (file, " bytes");
	444	}
4a020a8c	445
	446	rclass = reg_preferred_class (i);
	447	altclass = reg_alternate_class (i);
	448	if (rclass != GENERAL_REGS \|\| altclass != ALL_REGS)
	449	{
	450	if (altclass == ALL_REGS \|\| rclass == ALL_REGS)
	451	fprintf (file, "; pref %s", reg_class_names[(int) rclass]);
	452	else if (altclass == NO_REGS)
	453	fprintf (file, "; %s or none", reg_class_names[(int) rclass]);
	454	else
	455	fprintf (file, "; pref %s, else %s",
	456	reg_class_names[(int) rclass],
	457	reg_class_names[(int) altclass]);
	458	}
	459
	460	if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
	461	fputs ("; pointer", file);
	462	fputs (".\n", file);
	463	}
	464	}
	465