gcc/regstat.c

   1 /* Scanning of rtl for dataflow analysis.
   2    Copyright (C) 2007-2019 Free Software Foundation, Inc.
   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
   9 Software Foundation; either version 3, or (at your option) any later
  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
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "backend.h"
  26 #include "rtl.h"
  27 #include "predict.h"
  28 #include "df.h"
  29 #include "regs.h"
  30
  31
  32 struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs;
  33
  34 /*----------------------------------------------------------------------------
  35    REG_N_SETS and REG_N_REFS.
  36    ----------------------------------------------------------------------------*/
  37
  38 /* If a pass need to change these values in some magical way or the
  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
  55   regstat_n_sets_and_refs = XNEWVEC (struct regstat_n_sets_and_refs_t, max_regno);
  56
  57   if (MAY_HAVE_DEBUG_BIND_INSNS)
  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       }
  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
  97    Process REG_N_DEATHS, REG_N_CALLS_CROSSED, and REG_BASIC_BLOCK.
  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
 108    for basic block BB.  LIVE is a scratch bitvector used here.  */
 109
 110 static void
 111 regstat_bb_compute_ri (basic_block bb, bitmap live)
 112 {
 113   rtx_insn *insn;
 114   df_ref def, use;
 115   bitmap_iterator bi;
 116   unsigned int regno;
 117
 118   bitmap_copy (live, df_get_live_out (bb));
 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.  */
 127   FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
 128     if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
 129       bitmap_clear_bit (live, DF_REF_REGNO (def));
 130
 131   FOR_EACH_ARTIFICIAL_USE (use, bb->index)
 132     if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
 133       {
 134         regno = DF_REF_REGNO (use);
 135         bitmap_set_bit (live, regno);
 136       }
 137
 138   FOR_BB_INSNS_REVERSE (bb, insn)
 139     {
 140       struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
 141       bitmap_iterator bi;
 142       rtx link;
 143
 144       if (!NONDEBUG_INSN_P (insn))
 145         continue;
 146
 147       link = REG_NOTES (insn);
 148       while (link)
 149         {
 150           if (REG_NOTE_KIND (link) == REG_DEAD)
 151             REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
 152           link = XEXP (link, 1);
 153         }
 154
 155       /* Process the defs.  */
 156       if (CALL_P (insn))
 157         {
 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)++;
 162
 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         }
 178
 179       /* All of the defs except the return value are some sort of
 180          clobber.  This code is for the return.  */
 181       FOR_EACH_INSN_INFO_DEF (def, insn_info)
 182         {
 183           if ((!CALL_P (insn))
 184               || (!(DF_REF_FLAGS (def)
 185                     & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
 186             {
 187               unsigned int dregno = DF_REF_REGNO (def);
 188
 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);
 197
 198               if (dregno >= FIRST_PSEUDO_REGISTER)
 199                 {
 200                   REG_FREQ (dregno) += REG_FREQ_FROM_BB (bb);
 201                   REG_FREQ (dregno) =
 202                     MIN (REG_FREQ (dregno), REG_FREQ_MAX);
 203
 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                 }
 209             }
 210         }
 211
 212       FOR_EACH_INSN_INFO_USE (use, insn_info)
 213         {
 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);
 219               REG_FREQ (uregno) =
 220                 MIN (REG_FREQ (uregno), REG_FREQ_MAX);
 221
 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             }
 227         }
 228     }
 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);
 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;
 249   reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
 250
 251   FOR_EACH_BB_FN (bb, cfun)
 252     {
 253       regstat_bb_compute_ri (bb, live);
 254     }
 255
 256   BITMAP_FREE (live);
 257
 258   /* See the setjmp comment in regstat_bb_compute_ri.  */
 259   EXECUTE_IF_SET_IN_BITMAP (setjmp_crosses, FIRST_PSEUDO_REGISTER, regno, bi)
 260     {
 261       REG_BASIC_BLOCK (regno) = REG_BLOCK_UNKNOWN;
 262     }
 263
 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;
 275   free (reg_info_p);
 276   reg_info_p = NULL;
 277
 278   BITMAP_FREE (setjmp_crosses);
 279 }
 280
 281
 282 /* Return a bitmap containing the set of registers that cross a setjmp.
 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 /*----------------------------------------------------------------------------
 292    Process REG_N_CALLS_CROSSED.
 293
 294    This is used by sched_deps.  A good implementation of sched-deps
 295    would really process the blocks directly rather than going through
 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
 304 /* Compute calls crossed for BB. Live is a scratch bitvector.  */
 305
 306 static void
 307 regstat_bb_compute_calls_crossed (unsigned int bb_index, bitmap live)
 308 {
 309   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
 310   rtx_insn *insn;
 311   df_ref def, use;
 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.  */
 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));
 320
 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));
 324
 325   FOR_BB_INSNS_REVERSE (bb, insn)
 326     {
 327       struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
 328       unsigned int regno;
 329
 330       if (!NONDEBUG_INSN_P (insn))
 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)
 338             {
 339               REG_N_CALLS_CROSSED (regno)++;
 340             }
 341         }
 342
 343       /* All of the defs except the return value are some sort of
 344          clobber.  This code is for the return.  */
 345       FOR_EACH_INSN_INFO_DEF (def, insn_info)
 346         {
 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         }
 355
 356       FOR_EACH_INSN_INFO_USE (use, insn_info)
 357         bitmap_set_bit (live, DF_REF_REGNO (use));
 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;
 375   reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
 376
 377   FOR_EACH_BB_FN (bb, cfun)
 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;
 394   free (reg_info_p);
 395   reg_info_p = NULL;
 396 }
 397
 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)
 416         fprintf (file, "\nRegister %d used %d times",
 417                  i, REG_N_REFS (i));
 418       else if (df)
 419         fprintf (file, "\nRegister %d used %d times",
 420                  i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i));
 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));
 438       if (regno_reg_rtx[i] != NULL
 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         }
 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