LCOV - code coverage report
Current view: top level - gcc - df-scan.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1693 1913 88.5 %
Date: 2020-04-04 11:58:09 Functions: 86 96 89.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Scanning of rtl for dataflow analysis.
       2                 :            :    Copyright (C) 1999-2020 Free Software Foundation, Inc.
       3                 :            :    Originally contributed by Michael P. Hayes
       4                 :            :              (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
       5                 :            :    Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
       6                 :            :              and Kenneth Zadeck (zadeck@naturalbridge.com).
       7                 :            : 
       8                 :            : This file is part of GCC.
       9                 :            : 
      10                 :            : GCC is free software; you can redistribute it and/or modify it under
      11                 :            : the terms of the GNU General Public License as published by the Free
      12                 :            : Software Foundation; either version 3, or (at your option) any later
      13                 :            : version.
      14                 :            : 
      15                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      16                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      17                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      18                 :            : for more details.
      19                 :            : 
      20                 :            : You should have received a copy of the GNU General Public License
      21                 :            : along with GCC; see the file COPYING3.  If not see
      22                 :            : <http://www.gnu.org/licenses/>.  */
      23                 :            : 
      24                 :            : #include "config.h"
      25                 :            : #include "system.h"
      26                 :            : #include "coretypes.h"
      27                 :            : #include "backend.h"
      28                 :            : #include "target.h"
      29                 :            : #include "rtl.h"
      30                 :            : #include "tree.h"
      31                 :            : #include "df.h"
      32                 :            : #include "memmodel.h"
      33                 :            : #include "tm_p.h"
      34                 :            : #include "regs.h"
      35                 :            : #include "emit-rtl.h"  /* FIXME: Can go away once crtl is moved to rtl.h.  */
      36                 :            : #include "dumpfile.h"
      37                 :            : #include "calls.h"
      38                 :            : #include "function-abi.h"
      39                 :            : 
      40                 :            : /* The set of hard registers in eliminables[i].from. */
      41                 :            : 
      42                 :            : static HARD_REG_SET elim_reg_set;
      43                 :            : 
      44                 :            : /* Initialize ur_in and ur_out as if all hard registers were partially
      45                 :            :    available.  */
      46                 :            : 
      47                 :  227907000 : class df_collection_rec
      48                 :            : {
      49                 :            : public:
      50                 :            :   auto_vec<df_ref, 128> def_vec;
      51                 :            :   auto_vec<df_ref, 32> use_vec;
      52                 :            :   auto_vec<df_ref, 32> eq_use_vec;
      53                 :            :   auto_vec<df_mw_hardreg *, 32> mw_vec;
      54                 :            : };
      55                 :            : 
      56                 :            : static void df_ref_record (enum df_ref_class, class df_collection_rec *,
      57                 :            :                            rtx, rtx *,
      58                 :            :                            basic_block, struct df_insn_info *,
      59                 :            :                            enum df_ref_type, int ref_flags);
      60                 :            : static void df_def_record_1 (class df_collection_rec *, rtx *,
      61                 :            :                              basic_block, struct df_insn_info *,
      62                 :            :                              int ref_flags);
      63                 :            : static void df_defs_record (class df_collection_rec *, rtx,
      64                 :            :                             basic_block, struct df_insn_info *,
      65                 :            :                             int ref_flags);
      66                 :            : static void df_uses_record (class df_collection_rec *,
      67                 :            :                             rtx *, enum df_ref_type,
      68                 :            :                             basic_block, struct df_insn_info *,
      69                 :            :                             int ref_flags);
      70                 :            : 
      71                 :            : static void df_install_ref_incremental (df_ref);
      72                 :            : static void df_insn_refs_collect (class df_collection_rec*,
      73                 :            :                                   basic_block, struct df_insn_info *);
      74                 :            : static void df_canonize_collection_rec (class df_collection_rec *);
      75                 :            : 
      76                 :            : static void df_get_regular_block_artificial_uses (bitmap);
      77                 :            : static void df_get_eh_block_artificial_uses (bitmap);
      78                 :            : 
      79                 :            : static void df_record_entry_block_defs (bitmap);
      80                 :            : static void df_record_exit_block_uses (bitmap);
      81                 :            : static void df_get_exit_block_use_set (bitmap);
      82                 :            : static void df_get_entry_block_def_set (bitmap);
      83                 :            : static void df_grow_ref_info (struct df_ref_info *, unsigned int);
      84                 :            : static void df_ref_chain_delete_du_chain (df_ref);
      85                 :            : static void df_ref_chain_delete (df_ref);
      86                 :            : 
      87                 :            : static void df_refs_add_to_chains (class df_collection_rec *,
      88                 :            :                                    basic_block, rtx_insn *, unsigned int);
      89                 :            : 
      90                 :            : static bool df_insn_refs_verify (class df_collection_rec *, basic_block,
      91                 :            :                                  rtx_insn *, bool);
      92                 :            : static void df_entry_block_defs_collect (class df_collection_rec *, bitmap);
      93                 :            : static void df_exit_block_uses_collect (class df_collection_rec *, bitmap);
      94                 :            : static void df_install_ref (df_ref, struct df_reg_info *,
      95                 :            :                             struct df_ref_info *, bool);
      96                 :            : 
      97                 :            : static int df_ref_compare (df_ref, df_ref);
      98                 :            : static int df_ref_ptr_compare (const void *, const void *);
      99                 :            : static int df_mw_compare (const df_mw_hardreg *, const df_mw_hardreg *);
     100                 :            : static int df_mw_ptr_compare (const void *, const void *);
     101                 :            : 
     102                 :            : static void df_insn_info_delete (unsigned int);
     103                 :            : 
     104                 :            : /* Indexed by hardware reg number, is true if that register is ever
     105                 :            :    used in the current function.
     106                 :            : 
     107                 :            :    In df-scan.c, this is set up to record the hard regs used
     108                 :            :    explicitly.  Reload adds in the hard regs used for holding pseudo
     109                 :            :    regs.  Final uses it to generate the code in the function prologue
     110                 :            :    and epilogue to save and restore registers as needed.  */
     111                 :            : 
     112                 :            : static bool regs_ever_live[FIRST_PSEUDO_REGISTER];
     113                 :            : 
     114                 :            : /* Flags used to tell df_refs_add_to_chains() which vectors it should copy. */
     115                 :            : static const unsigned int copy_defs = 0x1;
     116                 :            : static const unsigned int copy_uses = 0x2;
     117                 :            : static const unsigned int copy_eq_uses = 0x4;
     118                 :            : static const unsigned int copy_mw = 0x8;
     119                 :            : static const unsigned int copy_all = copy_defs | copy_uses | copy_eq_uses
     120                 :            : | copy_mw;
     121                 :            : 
     122                 :            : /*----------------------------------------------------------------------------
     123                 :            :    SCANNING DATAFLOW PROBLEM
     124                 :            : 
     125                 :            :    There are several ways in which scanning looks just like the other
     126                 :            :    dataflow problems.  It shares the all the mechanisms for local info
     127                 :            :    as well as basic block info.  Where it differs is when and how often
     128                 :            :    it gets run.  It also has no need for the iterative solver.
     129                 :            : ----------------------------------------------------------------------------*/
     130                 :            : 
     131                 :            : /* Problem data for the scanning dataflow function.  */
     132                 :            : struct df_scan_problem_data
     133                 :            : {
     134                 :            :   object_allocator<df_base_ref> *ref_base_pool;
     135                 :            :   object_allocator<df_artificial_ref> *ref_artificial_pool;
     136                 :            :   object_allocator<df_regular_ref> *ref_regular_pool;
     137                 :            :   object_allocator<df_insn_info> *insn_pool;
     138                 :            :   object_allocator<df_reg_info> *reg_pool;
     139                 :            :   object_allocator<df_mw_hardreg> *mw_reg_pool;
     140                 :            : 
     141                 :            :   bitmap_obstack reg_bitmaps;
     142                 :            :   bitmap_obstack insn_bitmaps;
     143                 :            : };
     144                 :            : 
     145                 :            : /* Internal function to shut down the scanning problem.  */
     146                 :            : static void
     147                 :    1960450 : df_scan_free_internal (void)
     148                 :            : {
     149                 :    1960450 :   struct df_scan_problem_data *problem_data
     150                 :    1960450 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     151                 :            : 
     152                 :    1960450 :   free (df->def_info.refs);
     153                 :    1960450 :   free (df->def_info.begin);
     154                 :    1960450 :   free (df->def_info.count);
     155                 :    1960450 :   memset (&df->def_info, 0, (sizeof (struct df_ref_info)));
     156                 :            : 
     157                 :    1960450 :   free (df->use_info.refs);
     158                 :    1960450 :   free (df->use_info.begin);
     159                 :    1960450 :   free (df->use_info.count);
     160                 :    1960450 :   memset (&df->use_info, 0, (sizeof (struct df_ref_info)));
     161                 :            : 
     162                 :    1960450 :   free (df->def_regs);
     163                 :    1960450 :   df->def_regs = NULL;
     164                 :    1960450 :   free (df->use_regs);
     165                 :    1960450 :   df->use_regs = NULL;
     166                 :    1960450 :   free (df->eq_use_regs);
     167                 :    1960450 :   df->eq_use_regs = NULL;
     168                 :    1960450 :   df->regs_size = 0;
     169                 :    1960450 :   DF_REG_SIZE (df) = 0;
     170                 :            : 
     171                 :    1960450 :   free (df->insns);
     172                 :    1960450 :   df->insns = NULL;
     173                 :    1960450 :   DF_INSN_SIZE () = 0;
     174                 :            : 
     175                 :    1960450 :   free (df_scan->block_info);
     176                 :    1960450 :   df_scan->block_info = NULL;
     177                 :    1960450 :   df_scan->block_info_size = 0;
     178                 :            : 
     179                 :    1960450 :   bitmap_clear (&df->hardware_regs_used);
     180                 :    1960450 :   bitmap_clear (&df->regular_block_artificial_uses);
     181                 :    1960450 :   bitmap_clear (&df->eh_block_artificial_uses);
     182                 :    1960450 :   BITMAP_FREE (df->entry_block_defs);
     183                 :    1960450 :   BITMAP_FREE (df->exit_block_uses);
     184                 :    1960450 :   bitmap_clear (&df->insns_to_delete);
     185                 :    1960450 :   bitmap_clear (&df->insns_to_rescan);
     186                 :    1960450 :   bitmap_clear (&df->insns_to_notes_rescan);
     187                 :            : 
     188                 :    3920900 :   delete problem_data->ref_base_pool;
     189                 :    3920900 :   delete problem_data->ref_artificial_pool;
     190                 :    3920900 :   delete problem_data->ref_regular_pool;
     191                 :    3920900 :   delete problem_data->insn_pool;
     192                 :    3920900 :   delete problem_data->reg_pool;
     193                 :    3920900 :   delete problem_data->mw_reg_pool;
     194                 :    1960450 :   bitmap_obstack_release (&problem_data->reg_bitmaps);
     195                 :    1960450 :   bitmap_obstack_release (&problem_data->insn_bitmaps);
     196                 :    1960450 :   free (df_scan->problem_data);
     197                 :    1960450 : }
     198                 :            : 
     199                 :            : 
     200                 :            : /* Free basic block info.  */
     201                 :            : 
     202                 :            : static void
     203                 :    3923650 : df_scan_free_bb_info (basic_block bb, void *vbb_info)
     204                 :            : {
     205                 :    3923650 :   struct df_scan_bb_info *bb_info = (struct df_scan_bb_info *) vbb_info;
     206                 :    3923650 :   unsigned int bb_index = bb->index;
     207                 :    3923650 :   rtx_insn *insn;
     208                 :            : 
     209                 :    3923650 :   FOR_BB_INSNS (bb, insn)
     210                 :          0 :     if (INSN_P (insn))
     211                 :          0 :       df_insn_info_delete (INSN_UID (insn));
     212                 :            : 
     213                 :    3923650 :   if (bb_index < df_scan->block_info_size)
     214                 :    3923650 :     bb_info = df_scan_get_bb_info (bb_index);
     215                 :            : 
     216                 :            :   /* Get rid of any artificial uses or defs.  */
     217                 :    7847300 :   df_ref_chain_delete_du_chain (bb_info->artificial_defs);
     218                 :    7847300 :   df_ref_chain_delete_du_chain (bb_info->artificial_uses);
     219                 :    7847300 :   df_ref_chain_delete (bb_info->artificial_defs);
     220                 :    7847300 :   df_ref_chain_delete (bb_info->artificial_uses);
     221                 :    3923650 :   bb_info->artificial_defs = NULL;
     222                 :    3923650 :   bb_info->artificial_uses = NULL;
     223                 :    3923650 : }
     224                 :            : 
     225                 :            : 
     226                 :            : /* Allocate the problem data for the scanning problem.  This should be
     227                 :            :    called when the problem is created or when the entire function is to
     228                 :            :    be rescanned.  */
     229                 :            : void
     230                 :    1960450 : df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
     231                 :            : {
     232                 :    1960450 :   struct df_scan_problem_data *problem_data;
     233                 :    1960450 :   basic_block bb;
     234                 :            : 
     235                 :            :   /* Given the number of pools, this is really faster than tearing
     236                 :            :      everything apart.  */
     237                 :    1960450 :   if (df_scan->problem_data)
     238                 :    1016350 :     df_scan_free_internal ();
     239                 :            : 
     240                 :    1960450 :   problem_data = XNEW (struct df_scan_problem_data);
     241                 :    1960450 :   df_scan->problem_data = problem_data;
     242                 :    1960450 :   df_scan->computed = true;
     243                 :            : 
     244                 :    3920900 :   problem_data->ref_base_pool = new object_allocator<df_base_ref>
     245                 :    1960450 :     ("df_scan ref base");
     246                 :    3920900 :   problem_data->ref_artificial_pool = new object_allocator<df_artificial_ref>
     247                 :    1960450 :     ("df_scan ref artificial");
     248                 :    3920900 :   problem_data->ref_regular_pool = new object_allocator<df_regular_ref>
     249                 :    1960450 :     ("df_scan ref regular");
     250                 :    3920900 :   problem_data->insn_pool = new object_allocator<df_insn_info>
     251                 :    1960450 :     ("df_scan insn");
     252                 :    3920900 :   problem_data->reg_pool = new object_allocator<df_reg_info>
     253                 :    1960450 :     ("df_scan reg");
     254                 :    3920900 :   problem_data->mw_reg_pool = new object_allocator<df_mw_hardreg>
     255                 :    1960450 :     ("df_scan mw_reg");
     256                 :            : 
     257                 :    1960450 :   bitmap_obstack_initialize (&problem_data->reg_bitmaps);
     258                 :    1960450 :   bitmap_obstack_initialize (&problem_data->insn_bitmaps);
     259                 :            : 
     260                 :    1960450 :   df_grow_reg_info ();
     261                 :            : 
     262                 :    1960450 :   df_grow_insn_info ();
     263                 :    1960450 :   df_grow_bb_info (df_scan);
     264                 :            : 
     265                 :   25044700 :   FOR_ALL_BB_FN (bb, cfun)
     266                 :            :     {
     267                 :   23084200 :       unsigned int bb_index = bb->index;
     268                 :   23084200 :       struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
     269                 :   23084200 :       bb_info->artificial_defs = NULL;
     270                 :   23084200 :       bb_info->artificial_uses = NULL;
     271                 :            :     }
     272                 :            : 
     273                 :    1960450 :   bitmap_initialize (&df->hardware_regs_used, &problem_data->reg_bitmaps);
     274                 :    1960450 :   bitmap_initialize (&df->regular_block_artificial_uses, &problem_data->reg_bitmaps);
     275                 :    1960450 :   bitmap_initialize (&df->eh_block_artificial_uses, &problem_data->reg_bitmaps);
     276                 :    1960450 :   df->entry_block_defs = BITMAP_ALLOC (&problem_data->reg_bitmaps);
     277                 :    1960450 :   df->exit_block_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
     278                 :    1960450 :   bitmap_initialize (&df->insns_to_delete, &problem_data->insn_bitmaps);
     279                 :    1960450 :   bitmap_initialize (&df->insns_to_rescan, &problem_data->insn_bitmaps);
     280                 :    1960450 :   bitmap_initialize (&df->insns_to_notes_rescan, &problem_data->insn_bitmaps);
     281                 :    1960450 :   df_scan->optional_p = false;
     282                 :    1960450 : }
     283                 :            : 
     284                 :            : 
     285                 :            : /* Free all of the data associated with the scan problem.  */
     286                 :            : 
     287                 :            : static void
     288                 :     944099 : df_scan_free (void)
     289                 :            : {
     290                 :     944099 :   if (df_scan->problem_data)
     291                 :     944099 :     df_scan_free_internal ();
     292                 :            : 
     293                 :     944099 :   if (df->blocks_to_analyze)
     294                 :            :     {
     295                 :          0 :       BITMAP_FREE (df->blocks_to_analyze);
     296                 :          0 :       df->blocks_to_analyze = NULL;
     297                 :            :     }
     298                 :            : 
     299                 :     944099 :   free (df_scan);
     300                 :     944099 : }
     301                 :            : 
     302                 :            : /* Dump the preamble for DF_SCAN dump. */
     303                 :            : static void
     304                 :       3296 : df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
     305                 :            : {
     306                 :       3296 :   int i;
     307                 :       3296 :   int dcount = 0;
     308                 :       3296 :   int ucount = 0;
     309                 :       3296 :   int ecount = 0;
     310                 :       3296 :   int icount = 0;
     311                 :       3296 :   int ccount = 0;
     312                 :       3296 :   basic_block bb;
     313                 :       3296 :   rtx_insn *insn;
     314                 :            : 
     315                 :       3296 :   fprintf (file, ";;  fully invalidated by EH \t");
     316                 :       3296 :   df_print_regset
     317                 :       3296 :     (file, bitmap_view<HARD_REG_SET> (eh_edge_abi.full_reg_clobbers ()));
     318                 :       3296 :   fprintf (file, ";;  hardware regs used \t");
     319                 :       3296 :   df_print_regset (file, &df->hardware_regs_used);
     320                 :       3296 :   fprintf (file, ";;  regular block artificial uses \t");
     321                 :       3296 :   df_print_regset (file, &df->regular_block_artificial_uses);
     322                 :       3296 :   fprintf (file, ";;  eh block artificial uses \t");
     323                 :       3296 :   df_print_regset (file, &df->eh_block_artificial_uses);
     324                 :       3296 :   fprintf (file, ";;  entry block defs \t");
     325                 :       3296 :   df_print_regset (file, df->entry_block_defs);
     326                 :       3296 :   fprintf (file, ";;  exit block uses \t");
     327                 :       3296 :   df_print_regset (file, df->exit_block_uses);
     328                 :       3296 :   fprintf (file, ";;  regs ever live \t");
     329                 :     253792 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     330                 :     250496 :     if (df_regs_ever_live_p (i))
     331                 :      17354 :       fprintf (file, " %d [%s]", i, reg_names[i]);
     332                 :       3296 :   fprintf (file, "\n;;  ref usage \t");
     333                 :            : 
     334                 :     355374 :   for (i = 0; i < (int)df->regs_inited; i++)
     335                 :     352078 :     if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i) || DF_REG_EQ_USE_COUNT (i))
     336                 :            :       {
     337                 :     163501 :         const char * sep = "";
     338                 :            : 
     339                 :     163501 :         fprintf (file, "r%d={", i);
     340                 :     163501 :         if (DF_REG_DEF_COUNT (i))
     341                 :            :           {
     342                 :     163492 :             fprintf (file, "%dd", DF_REG_DEF_COUNT (i));
     343                 :     163492 :             sep = ",";
     344                 :     163492 :             dcount += DF_REG_DEF_COUNT (i);
     345                 :            :           }
     346                 :     163501 :         if (DF_REG_USE_COUNT (i))
     347                 :            :           {
     348                 :      46065 :             fprintf (file, "%s%du", sep, DF_REG_USE_COUNT (i));
     349                 :      46065 :             sep = ",";
     350                 :      46065 :             ucount += DF_REG_USE_COUNT (i);
     351                 :            :           }
     352                 :     163501 :         if (DF_REG_EQ_USE_COUNT (i))
     353                 :            :           {
     354                 :       2426 :             fprintf (file, "%s%de", sep, DF_REG_EQ_USE_COUNT (i));
     355                 :       2426 :             ecount += DF_REG_EQ_USE_COUNT (i);
     356                 :            :           }
     357                 :     163501 :         fprintf (file, "} ");
     358                 :            :       }
     359                 :            : 
     360                 :      25986 :   FOR_EACH_BB_FN (bb, cfun)
     361                 :     329188 :     FOR_BB_INSNS (bb, insn)
     362                 :     153249 :       if (INSN_P (insn))
     363                 :            :         {
     364                 :     105430 :           if (CALL_P (insn))
     365                 :       6895 :             ccount++;
     366                 :            :           else
     367                 :      98535 :             icount++;
     368                 :            :         }
     369                 :            : 
     370                 :       3296 :   fprintf (file, "\n;;    total ref usage %d{%dd,%du,%de}"
     371                 :            :                  " in %d{%d regular + %d call} insns.\n",
     372                 :       3296 :                  dcount + ucount + ecount, dcount, ucount, ecount,
     373                 :            :                  icount + ccount, icount, ccount);
     374                 :       3296 : }
     375                 :            : 
     376                 :            : /* Dump the bb_info for a given basic block. */
     377                 :            : static void
     378                 :       4364 : df_scan_start_block (basic_block bb, FILE *file)
     379                 :            : {
     380                 :       4364 :   struct df_scan_bb_info *bb_info
     381                 :       4364 :     = df_scan_get_bb_info (bb->index);
     382                 :            : 
     383                 :       4364 :   if (bb_info)
     384                 :            :     {
     385                 :       4364 :       fprintf (file, ";; bb %d artificial_defs: ", bb->index);
     386                 :       4364 :       df_refs_chain_dump (bb_info->artificial_defs, true, file);
     387                 :       4364 :       fprintf (file, "\n;; bb %d artificial_uses: ", bb->index);
     388                 :       4364 :       df_refs_chain_dump (bb_info->artificial_uses, true, file);
     389                 :       4364 :       fprintf (file, "\n");
     390                 :            :     }
     391                 :            : #if 0
     392                 :            :   {
     393                 :            :     rtx_insn *insn;
     394                 :            :     FOR_BB_INSNS (bb, insn)
     395                 :            :       if (INSN_P (insn))
     396                 :            :         df_insn_debug (insn, false, file);
     397                 :            :   }
     398                 :            : #endif
     399                 :       4364 : }
     400                 :            : 
     401                 :            : static const struct df_problem problem_SCAN =
     402                 :            : {
     403                 :            :   DF_SCAN,                    /* Problem id.  */
     404                 :            :   DF_NONE,                    /* Direction.  */
     405                 :            :   df_scan_alloc,              /* Allocate the problem specific data.  */
     406                 :            :   NULL,                       /* Reset global information.  */
     407                 :            :   df_scan_free_bb_info,       /* Free basic block info.  */
     408                 :            :   NULL,                       /* Local compute function.  */
     409                 :            :   NULL,                       /* Init the solution specific data.  */
     410                 :            :   NULL,                       /* Iterative solver.  */
     411                 :            :   NULL,                       /* Confluence operator 0.  */
     412                 :            :   NULL,                       /* Confluence operator n.  */
     413                 :            :   NULL,                       /* Transfer function.  */
     414                 :            :   NULL,                       /* Finalize function.  */
     415                 :            :   df_scan_free,               /* Free all of the problem information.  */
     416                 :            :   NULL,                       /* Remove this problem from the stack of dataflow problems.  */
     417                 :            :   df_scan_start_dump,         /* Debugging.  */
     418                 :            :   df_scan_start_block,        /* Debugging start block.  */
     419                 :            :   NULL,                       /* Debugging end block.  */
     420                 :            :   NULL,                       /* Debugging start insn.  */
     421                 :            :   NULL,                       /* Debugging end insn.  */
     422                 :            :   NULL,                       /* Incremental solution verify start.  */
     423                 :            :   NULL,                       /* Incremental solution verify end.  */
     424                 :            :   NULL,                       /* Dependent problem.  */
     425                 :            :   sizeof (struct df_scan_bb_info),/* Size of entry of block_info array.  */
     426                 :            :   TV_DF_SCAN,                 /* Timing variable.  */
     427                 :            :   false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
     428                 :            : };
     429                 :            : 
     430                 :            : 
     431                 :            : /* Create a new DATAFLOW instance and add it to an existing instance
     432                 :            :    of DF.  The returned structure is what is used to get at the
     433                 :            :    solution.  */
     434                 :            : 
     435                 :            : void
     436                 :     944099 : df_scan_add_problem (void)
     437                 :            : {
     438                 :     944099 :   df_add_problem (&problem_SCAN);
     439                 :     944099 : }
     440                 :            : 
     441                 :            : 
     442                 :            : /*----------------------------------------------------------------------------
     443                 :            :    Storage Allocation Utilities
     444                 :            : ----------------------------------------------------------------------------*/
     445                 :            : 
     446                 :            : 
     447                 :            : /* First, grow the reg_info information.  If the current size is less than
     448                 :            :    the number of pseudos, grow to 25% more than the number of
     449                 :            :    pseudos.
     450                 :            : 
     451                 :            :    Second, assure that all of the slots up to max_reg_num have been
     452                 :            :    filled with reg_info structures.  */
     453                 :            : 
     454                 :            : void
     455                 :  223080000 : df_grow_reg_info (void)
     456                 :            : {
     457                 :  223080000 :   unsigned int max_reg = max_reg_num ();
     458                 :  223080000 :   unsigned int new_size = max_reg;
     459                 :  223080000 :   struct df_scan_problem_data *problem_data
     460                 :  223080000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     461                 :  223080000 :   unsigned int i;
     462                 :            : 
     463                 :  223080000 :   if (df->regs_size < new_size)
     464                 :            :     {
     465                 :    1994440 :       new_size += new_size / 4;
     466                 :    1994440 :       df->def_regs = XRESIZEVEC (struct df_reg_info *, df->def_regs, new_size);
     467                 :    1994440 :       df->use_regs = XRESIZEVEC (struct df_reg_info *, df->use_regs, new_size);
     468                 :    1994440 :       df->eq_use_regs = XRESIZEVEC (struct df_reg_info *, df->eq_use_regs,
     469                 :            :                                     new_size);
     470                 :    1994440 :       df->def_info.begin = XRESIZEVEC (unsigned, df->def_info.begin, new_size);
     471                 :    1994440 :       df->def_info.count = XRESIZEVEC (unsigned, df->def_info.count, new_size);
     472                 :    1994440 :       df->use_info.begin = XRESIZEVEC (unsigned, df->use_info.begin, new_size);
     473                 :    1994440 :       df->use_info.count = XRESIZEVEC (unsigned, df->use_info.count, new_size);
     474                 :    1994440 :       df->regs_size = new_size;
     475                 :            :     }
     476                 :            : 
     477                 :  468845000 :   for (i = df->regs_inited; i < max_reg; i++)
     478                 :            :     {
     479                 :  245765000 :       struct df_reg_info *reg_info;
     480                 :            : 
     481                 :            :       // TODO
     482                 :  245765000 :       reg_info = problem_data->reg_pool->allocate ();
     483                 :  245765000 :       memset (reg_info, 0, sizeof (struct df_reg_info));
     484                 :  245765000 :       df->def_regs[i] = reg_info;
     485                 :  245765000 :       reg_info = problem_data->reg_pool->allocate ();
     486                 :  245765000 :       memset (reg_info, 0, sizeof (struct df_reg_info));
     487                 :  245765000 :       df->use_regs[i] = reg_info;
     488                 :  245765000 :       reg_info = problem_data->reg_pool->allocate ();
     489                 :  245765000 :       memset (reg_info, 0, sizeof (struct df_reg_info));
     490                 :  245765000 :       df->eq_use_regs[i] = reg_info;
     491                 :  245765000 :       df->def_info.begin[i] = 0;
     492                 :  245765000 :       df->def_info.count[i] = 0;
     493                 :  245765000 :       df->use_info.begin[i] = 0;
     494                 :  245765000 :       df->use_info.count[i] = 0;
     495                 :            :     }
     496                 :            : 
     497                 :  223080000 :   df->regs_inited = max_reg;
     498                 :  223080000 : }
     499                 :            : 
     500                 :            : 
     501                 :            : /* Grow the ref information.  */
     502                 :            : 
     503                 :            : static void
     504                 :    4265210 : df_grow_ref_info (struct df_ref_info *ref_info, unsigned int new_size)
     505                 :            : {
     506                 :    4265210 :   if (ref_info->refs_size < new_size)
     507                 :            :     {
     508                 :    4265210 :       ref_info->refs = XRESIZEVEC (df_ref, ref_info->refs, new_size);
     509                 :    4265210 :       memset (ref_info->refs + ref_info->refs_size, 0,
     510                 :    4265210 :               (new_size - ref_info->refs_size) *sizeof (df_ref));
     511                 :    4265210 :       ref_info->refs_size = new_size;
     512                 :            :     }
     513                 :    4265210 : }
     514                 :            : 
     515                 :            : 
     516                 :            : /* Check and grow the ref information if necessary.  This routine
     517                 :            :    guarantees total_size + BITMAP_ADDEND amount of entries in refs
     518                 :            :    array.  It updates ref_info->refs_size only and does not change
     519                 :            :    ref_info->total_size.  */
     520                 :            : 
     521                 :            : static void
     522                 :    7142160 : df_check_and_grow_ref_info (struct df_ref_info *ref_info,
     523                 :            :                             unsigned bitmap_addend)
     524                 :            : {
     525                 :          0 :   if (ref_info->refs_size < ref_info->total_size + bitmap_addend)
     526                 :            :     {
     527                 :    4265210 :       int new_size = ref_info->total_size + bitmap_addend;
     528                 :    4265210 :       new_size += ref_info->total_size / 4;
     529                 :    4265210 :       df_grow_ref_info (ref_info, new_size);
     530                 :            :     }
     531                 :          0 : }
     532                 :            : 
     533                 :            : 
     534                 :            : /* Grow the ref information.  If the current size is less than the
     535                 :            :    number of instructions, grow to 25% more than the number of
     536                 :            :    instructions.  */
     537                 :            : 
     538                 :            : void
     539                 :  268842000 : df_grow_insn_info (void)
     540                 :            : {
     541                 :  268842000 :   unsigned int new_size = get_max_uid () + 1;
     542                 :  268842000 :   if (DF_INSN_SIZE () < new_size)
     543                 :            :     {
     544                 :    2631820 :       new_size += new_size / 4;
     545                 :    2631820 :       df->insns = XRESIZEVEC (struct df_insn_info *, df->insns, new_size);
     546                 :    2631820 :       memset (df->insns + df->insns_size, 0,
     547                 :    2631820 :               (new_size - DF_INSN_SIZE ()) *sizeof (struct df_insn_info *));
     548                 :    2631820 :       DF_INSN_SIZE () = new_size;
     549                 :            :     }
     550                 :  268842000 : }
     551                 :            : 
     552                 :            : 
     553                 :            : 
     554                 :            : 
     555                 :            : /*----------------------------------------------------------------------------
     556                 :            :    PUBLIC INTERFACES FOR SMALL GRAIN CHANGES TO SCANNING.
     557                 :            : ----------------------------------------------------------------------------*/
     558                 :            : 
     559                 :            : /* Rescan all of the block_to_analyze or all of the blocks in the
     560                 :            :    function if df_set_blocks if blocks_to_analyze is NULL;  */
     561                 :            : 
     562                 :            : void
     563                 :    1960450 : df_scan_blocks (void)
     564                 :            : {
     565                 :    1960450 :   basic_block bb;
     566                 :            : 
     567                 :    1960450 :   df->def_info.ref_order = DF_REF_ORDER_NO_TABLE;
     568                 :    1960450 :   df->use_info.ref_order = DF_REF_ORDER_NO_TABLE;
     569                 :            : 
     570                 :    1960450 :   df_get_regular_block_artificial_uses (&df->regular_block_artificial_uses);
     571                 :    1960450 :   df_get_eh_block_artificial_uses (&df->eh_block_artificial_uses);
     572                 :            : 
     573                 :    1960450 :   bitmap_ior_into (&df->eh_block_artificial_uses,
     574                 :    1960450 :                    &df->regular_block_artificial_uses);
     575                 :            : 
     576                 :            :   /* ENTRY and EXIT blocks have special defs/uses.  */
     577                 :    1960450 :   df_get_entry_block_def_set (df->entry_block_defs);
     578                 :    1960450 :   df_record_entry_block_defs (df->entry_block_defs);
     579                 :    1960450 :   df_get_exit_block_use_set (df->exit_block_uses);
     580                 :    1960450 :   df_record_exit_block_uses (df->exit_block_uses);
     581                 :    1960450 :   df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK));
     582                 :    1960450 :   df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK));
     583                 :            : 
     584                 :            :   /* Regular blocks */
     585                 :   21123800 :   FOR_EACH_BB_FN (bb, cfun)
     586                 :            :     {
     587                 :   19163300 :       unsigned int bb_index = bb->index;
     588                 :   19163300 :       df_bb_refs_record (bb_index, true);
     589                 :            :     }
     590                 :    1960450 : }
     591                 :            : 
     592                 :            : /* Create new refs under address LOC within INSN.  This function is
     593                 :            :    only used externally.  REF_FLAGS must be either 0 or DF_REF_IN_NOTE,
     594                 :            :    depending on whether LOC is inside PATTERN (INSN) or a note.  */
     595                 :            : 
     596                 :            : void
     597                 :    2153770 : df_uses_create (rtx *loc, rtx_insn *insn, int ref_flags)
     598                 :            : {
     599                 :    2153770 :   gcc_assert (!(ref_flags & ~DF_REF_IN_NOTE));
     600                 :    4307550 :   df_uses_record (NULL, loc, DF_REF_REG_USE,
     601                 :    2153770 :                   BLOCK_FOR_INSN (insn),
     602                 :    2153770 :                   DF_INSN_INFO_GET (insn),
     603                 :            :                   ref_flags);
     604                 :    2153770 : }
     605                 :            : 
     606                 :            : static void
     607                 :    2381610 : df_install_ref_incremental (df_ref ref)
     608                 :            : {
     609                 :    2381610 :   struct df_reg_info **reg_info;
     610                 :    2381610 :   struct df_ref_info *ref_info;
     611                 :    2381610 :   df_ref *ref_ptr;
     612                 :    2381610 :   bool add_to_table;
     613                 :            : 
     614                 :    2381610 :   rtx_insn *insn = DF_REF_INSN (ref);
     615                 :    2381610 :   basic_block bb = BLOCK_FOR_INSN (insn);
     616                 :            : 
     617                 :    2381610 :   if (DF_REF_REG_DEF_P (ref))
     618                 :            :     {
     619                 :      36930 :       reg_info = df->def_regs;
     620                 :      36930 :       ref_info = &df->def_info;
     621                 :      36930 :       ref_ptr = &DF_INSN_DEFS (insn);
     622                 :      36930 :       add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
     623                 :            :     }
     624                 :    2344680 :   else if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
     625                 :            :     {
     626                 :     274564 :       reg_info = df->eq_use_regs;
     627                 :     274564 :       ref_info = &df->use_info;
     628                 :     274564 :       ref_ptr = &DF_INSN_EQ_USES (insn);
     629                 :     274564 :       switch (ref_info->ref_order)
     630                 :            :         {
     631                 :            :         case DF_REF_ORDER_UNORDERED_WITH_NOTES:
     632                 :            :         case DF_REF_ORDER_BY_REG_WITH_NOTES:
     633                 :            :         case DF_REF_ORDER_BY_INSN_WITH_NOTES:
     634                 :            :           add_to_table = true;
     635                 :            :           break;
     636                 :          0 :         default:
     637                 :          0 :           add_to_table = false;
     638                 :          0 :           break;
     639                 :            :         }
     640                 :            :     }
     641                 :            :   else
     642                 :            :     {
     643                 :    2070120 :       reg_info = df->use_regs;
     644                 :    2070120 :       ref_info = &df->use_info;
     645                 :    2070120 :       ref_ptr = &DF_INSN_USES (insn);
     646                 :    2070120 :       add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
     647                 :            :     }
     648                 :            : 
     649                 :            :   /* Do not add if ref is not in the right blocks.  */
     650                 :    2381610 :   if (add_to_table && df->analyze_subset)
     651                 :          0 :     add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
     652                 :            : 
     653                 :    2381610 :   df_install_ref (ref, reg_info[DF_REF_REGNO (ref)], ref_info, add_to_table);
     654                 :            : 
     655                 :    2381610 :   if (add_to_table)
     656                 :    2344680 :     switch (ref_info->ref_order)
     657                 :            :       {
     658                 :    2344680 :       case DF_REF_ORDER_UNORDERED_WITH_NOTES:
     659                 :    2344680 :       case DF_REF_ORDER_BY_REG_WITH_NOTES:
     660                 :    2344680 :       case DF_REF_ORDER_BY_INSN_WITH_NOTES:
     661                 :    2344680 :         ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
     662                 :    2344680 :         break;
     663                 :          0 :       default:
     664                 :          0 :         ref_info->ref_order = DF_REF_ORDER_UNORDERED;
     665                 :          0 :         break;
     666                 :            :       }
     667                 :            : 
     668                 :    5485450 :   while (*ref_ptr && df_ref_compare (*ref_ptr, ref) < 0)
     669                 :    3103840 :     ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
     670                 :            : 
     671                 :    2381610 :   DF_REF_NEXT_LOC (ref) = *ref_ptr;
     672                 :    2381610 :   *ref_ptr = ref;
     673                 :            : 
     674                 :            : #if 0
     675                 :            :   if (dump_file)
     676                 :            :     {
     677                 :            :       fprintf (dump_file, "adding ref ");
     678                 :            :       df_ref_debug (ref, dump_file);
     679                 :            :     }
     680                 :            : #endif
     681                 :            :   /* By adding the ref directly, df_insn_rescan my not find any
     682                 :            :      differences even though the block will have changed.  So we need
     683                 :            :      to mark the block dirty ourselves.  */
     684                 :    2381610 :   if (!DEBUG_INSN_P (DF_REF_INSN (ref)))
     685                 :    2116600 :     df_set_bb_dirty (bb);
     686                 :    2381610 : }
     687                 :            : 
     688                 :            : 
     689                 :            : 
     690                 :            : /*----------------------------------------------------------------------------
     691                 :            :    UTILITIES TO CREATE AND DESTROY REFS AND CHAINS.
     692                 :            : ----------------------------------------------------------------------------*/
     693                 :            : 
     694                 :            : static void
     695                 : 3215770000 : df_free_ref (df_ref ref)
     696                 :            : {
     697                 : 3215770000 :   struct df_scan_problem_data *problem_data
     698                 : 3215770000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     699                 :            : 
     700                 : 3215770000 :   switch (DF_REF_CLASS (ref))
     701                 :            :     {
     702                 : 2341820000 :     case DF_REF_BASE:
     703                 : 2341820000 :       problem_data->ref_base_pool->remove ((df_base_ref *) (ref));
     704                 :            :       break;
     705                 :            : 
     706                 :  207166000 :     case DF_REF_ARTIFICIAL:
     707                 :  207166000 :       problem_data->ref_artificial_pool->remove
     708                 : 3215770000 :         ((df_artificial_ref *) (ref));
     709                 :            :       break;
     710                 :            : 
     711                 :  666787000 :     case DF_REF_REGULAR:
     712                 :  666787000 :       problem_data->ref_regular_pool->remove
     713                 : 3215770000 :         ((df_regular_ref *) (ref));
     714                 :            :       break;
     715                 :            :     }
     716                 : 3215770000 : }
     717                 :            : 
     718                 :            : 
     719                 :            : /* Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain.
     720                 :            :    Also delete the def-use or use-def chain if it exists.  */
     721                 :            : 
     722                 :            : static void
     723                 :  171669000 : df_reg_chain_unlink (df_ref ref)
     724                 :            : {
     725                 :  171669000 :   df_ref next = DF_REF_NEXT_REG (ref);
     726                 :  171669000 :   df_ref prev = DF_REF_PREV_REG (ref);
     727                 :  171669000 :   int id = DF_REF_ID (ref);
     728                 :  171669000 :   struct df_reg_info *reg_info;
     729                 :  171669000 :   df_ref *refs = NULL;
     730                 :            : 
     731                 :  171669000 :   if (DF_REF_REG_DEF_P (ref))
     732                 :            :     {
     733                 :   79395000 :       int regno = DF_REF_REGNO (ref);
     734                 :   79395000 :       reg_info = DF_REG_DEF_GET (regno);
     735                 :   79395000 :       refs = df->def_info.refs;
     736                 :            :     }
     737                 :            :   else
     738                 :            :     {
     739                 :   92274000 :       if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
     740                 :            :         {
     741                 :   10112000 :           reg_info = DF_REG_EQ_USE_GET (DF_REF_REGNO (ref));
     742                 :   10112000 :           switch (df->use_info.ref_order)
     743                 :            :             {
     744                 :          0 :             case DF_REF_ORDER_UNORDERED_WITH_NOTES:
     745                 :          0 :             case DF_REF_ORDER_BY_REG_WITH_NOTES:
     746                 :          0 :             case DF_REF_ORDER_BY_INSN_WITH_NOTES:
     747                 :          0 :               refs = df->use_info.refs;
     748                 :          0 :               break;
     749                 :            :             default:
     750                 :            :               break;
     751                 :            :             }
     752                 :            :         }
     753                 :            :       else
     754                 :            :         {
     755                 :   82162000 :           reg_info = DF_REG_USE_GET (DF_REF_REGNO (ref));
     756                 :   82162000 :           refs = df->use_info.refs;
     757                 :            :         }
     758                 :            :     }
     759                 :            : 
     760                 :  161557000 :   if (refs)
     761                 :            :     {
     762                 :     666073 :       if (df->analyze_subset)
     763                 :            :         {
     764                 :     379751 :           if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BBNO (ref)))
     765                 :     205835 :             refs[id] = NULL;
     766                 :            :         }
     767                 :            :       else
     768                 :     286322 :         refs[id] = NULL;
     769                 :            :     }
     770                 :            : 
     771                 :            :   /* Delete any def-use or use-def chains that start here. It is
     772                 :            :      possible that there is trash in this field.  This happens for
     773                 :            :      insns that have been deleted when rescanning has been deferred
     774                 :            :      and the chain problem has also been deleted.  The chain tear down
     775                 :            :      code skips deleted insns.  */
     776                 :  171669000 :   if (df_chain && DF_REF_CHAIN (ref))
     777                 :          0 :     df_chain_unlink (ref);
     778                 :            : 
     779                 :  171669000 :   reg_info->n_refs--;
     780                 :  171669000 :   if (DF_REF_FLAGS_IS_SET (ref, DF_HARD_REG_LIVE))
     781                 :            :     {
     782                 :   49509700 :       gcc_assert (DF_REF_REGNO (ref) < FIRST_PSEUDO_REGISTER);
     783                 :   49509700 :       df->hard_regs_live_count[DF_REF_REGNO (ref)]--;
     784                 :            :     }
     785                 :            : 
     786                 :            :   /* Unlink from the reg chain.  If there is no prev, this is the
     787                 :            :      first of the list.  If not, just join the next and prev.  */
     788                 :  171669000 :   if (prev)
     789                 :  117295000 :     DF_REF_NEXT_REG (prev) = next;
     790                 :            :   else
     791                 :            :     {
     792                 :   54373600 :       gcc_assert (reg_info->reg_chain == ref);
     793                 :   54373600 :       reg_info->reg_chain = next;
     794                 :            :     }
     795                 :  171669000 :   if (next)
     796                 :  100874000 :     DF_REF_PREV_REG (next) = prev;
     797                 :            : 
     798                 :  171669000 :   df_free_ref (ref);
     799                 :  171669000 : }
     800                 :            : 
     801                 :            : /* Initialize INSN_INFO to describe INSN.  */
     802                 :            : 
     803                 :            : static void
     804                 :  273998000 : df_insn_info_init_fields (df_insn_info *insn_info, rtx_insn *insn)
     805                 :            : {
     806                 :  273998000 :   memset (insn_info, 0, sizeof (struct df_insn_info));
     807                 :  273998000 :   insn_info->insn = insn;
     808                 :          0 : }
     809                 :            : 
     810                 :            : /* Create the insn record for INSN.  If there was one there, zero it
     811                 :            :    out.  */
     812                 :            : 
     813                 :            : struct df_insn_info *
     814                 :  243475000 : df_insn_create_insn_record (rtx_insn *insn)
     815                 :            : {
     816                 :  243475000 :   struct df_scan_problem_data *problem_data
     817                 :  243475000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     818                 :  243475000 :   struct df_insn_info *insn_rec;
     819                 :            : 
     820                 :  243475000 :   df_grow_insn_info ();
     821                 :  243475000 :   insn_rec = DF_INSN_INFO_GET (insn);
     822                 :  243475000 :   if (!insn_rec)
     823                 :            :     {
     824                 :  243475000 :       insn_rec = problem_data->insn_pool->allocate ();
     825                 :  243475000 :       DF_INSN_INFO_SET (insn, insn_rec);
     826                 :            :     }
     827                 :  243475000 :   df_insn_info_init_fields (insn_rec, insn);
     828                 :  243475000 :   return insn_rec;
     829                 :            : }
     830                 :            : 
     831                 :            : 
     832                 :            : /* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain.  */
     833                 :            : 
     834                 :            : static void
     835                 :    7847300 : df_ref_chain_delete_du_chain (df_ref ref)
     836                 :            : {
     837                 :   39145000 :   for (; ref; ref = DF_REF_NEXT_LOC (ref))
     838                 :            :     /* CHAIN is allocated by DF_CHAIN. So make sure to
     839                 :            :        pass df_scan instance for the problem.  */
     840                 :   28993300 :     if (DF_REF_CHAIN (ref))
     841                 :     156150 :       df_chain_unlink (ref);
     842                 :          0 : }
     843                 :            : 
     844                 :            : 
     845                 :            : /* Delete all refs in the ref chain.  */
     846                 :            : 
     847                 :            : static void
     848                 :    7847300 : df_ref_chain_delete (df_ref ref)
     849                 :            : {
     850                 :  450002000 :   df_ref next;
     851                 :  450002000 :   for (; ref; ref = next)
     852                 :            :     {
     853                 :  171669000 :       next = DF_REF_NEXT_LOC (ref);
     854                 :  171669000 :       df_reg_chain_unlink (ref);
     855                 :            :     }
     856                 :          0 : }
     857                 :            : 
     858                 :            : 
     859                 :            : /* Delete the hardreg chain.  */
     860                 :            : 
     861                 :            : static void
     862                 :   84802200 : df_mw_hardreg_chain_delete (struct df_mw_hardreg *hardregs)
     863                 :            : {
     864                 :   84802200 :   struct df_scan_problem_data *problem_data
     865                 :   84802200 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     866                 :   85749900 :   df_mw_hardreg *next;
     867                 :            : 
     868                 :   85749900 :   for (; hardregs; hardregs = next)
     869                 :            :     {
     870                 :     947747 :       next = DF_MWS_NEXT (hardregs);
     871                 :     947747 :       problem_data->mw_reg_pool->remove (hardregs);
     872                 :            :     }
     873                 :   84802200 : }
     874                 :            : 
     875                 :            : /* Remove the contents of INSN_INFO (but don't free INSN_INFO itself).  */
     876                 :            : 
     877                 :            : static void
     878                 :   84777400 : df_insn_info_free_fields (df_insn_info *insn_info)
     879                 :            : {
     880                 :            :   /* In general, notes do not have the insn_info fields
     881                 :            :      initialized.  However, combine deletes insns by changing them
     882                 :            :      to notes.  How clever.  So we cannot just check if it is a
     883                 :            :      valid insn before short circuiting this code, we need to see
     884                 :            :      if we actually initialized it.  */
     885                 :   84777400 :   df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
     886                 :            : 
     887                 :   84777400 :   if (df_chain)
     888                 :            :     {
     889                 :     248383 :       df_ref_chain_delete_du_chain (insn_info->defs);
     890                 :     248383 :       df_ref_chain_delete_du_chain (insn_info->uses);
     891                 :     248383 :       df_ref_chain_delete_du_chain (insn_info->eq_uses);
     892                 :            :     }
     893                 :            : 
     894                 :   84777400 :   df_ref_chain_delete (insn_info->defs);
     895                 :   84777400 :   df_ref_chain_delete (insn_info->uses);
     896                 :   84777400 :   df_ref_chain_delete (insn_info->eq_uses);
     897                 :   84777400 : }
     898                 :            : 
     899                 :            : /* Delete all of the refs information from the insn with UID.
     900                 :            :    Internal helper for df_insn_delete, df_insn_rescan, and other
     901                 :            :    df-scan routines that don't have to work in deferred mode
     902                 :            :    and do not have to mark basic blocks for re-processing.  */
     903                 :            : 
     904                 :            : static void
     905                 :   59938300 : df_insn_info_delete (unsigned int uid)
     906                 :            : {
     907                 :   59938300 :   struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
     908                 :            : 
     909                 :   59938300 :   bitmap_clear_bit (&df->insns_to_delete, uid);
     910                 :   59938300 :   bitmap_clear_bit (&df->insns_to_rescan, uid);
     911                 :   59938300 :   bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
     912                 :   59938300 :   if (insn_info)
     913                 :            :     {
     914                 :   54255100 :       struct df_scan_problem_data *problem_data
     915                 :   54255100 :         = (struct df_scan_problem_data *) df_scan->problem_data;
     916                 :            : 
     917                 :   54255100 :       df_insn_info_free_fields (insn_info);
     918                 :   54255100 :       problem_data->insn_pool->remove (insn_info);
     919                 :   54255100 :       DF_INSN_UID_SET (uid, NULL);
     920                 :            :     }
     921                 :   59938300 : }
     922                 :            : 
     923                 :            : /* Delete all of the refs information from INSN, either right now
     924                 :            :    or marked for later in deferred mode.  */
     925                 :            : 
     926                 :            : void
     927                 :   66183200 : df_insn_delete (rtx_insn *insn)
     928                 :            : {
     929                 :   66183200 :   unsigned int uid;
     930                 :   66183200 :   basic_block bb;
     931                 :            : 
     932                 :   66183200 :   gcc_checking_assert (INSN_P (insn));
     933                 :            : 
     934                 :   66183200 :   if (!df)
     935                 :            :     return;
     936                 :            : 
     937                 :   59940600 :   uid = INSN_UID (insn);
     938                 :   59940600 :   bb = BLOCK_FOR_INSN (insn);
     939                 :            : 
     940                 :            :   /* ??? bb can be NULL after pass_free_cfg.  At that point, DF should
     941                 :            :      not exist anymore (as mentioned in df-core.c: "The only requirement
     942                 :            :      [for DF] is that there be a correct control flow graph."  Clearly
     943                 :            :      that isn't the case after pass_free_cfg.  But DF is freed much later
     944                 :            :      because some back-ends want to use DF info even though the CFG is
     945                 :            :      already gone.  It's not clear to me whether that is safe, actually.
     946                 :            :      In any case, we expect BB to be non-NULL at least up to register
     947                 :            :      allocation, so disallow a non-NULL BB up to there.  Not perfect
     948                 :            :      but better than nothing...  */
     949                 :   59940600 :   gcc_checking_assert (bb != NULL || reload_completed);
     950                 :            : 
     951                 :   59940600 :   df_grow_bb_info (df_scan);
     952                 :   59940600 :   df_grow_reg_info ();
     953                 :            : 
     954                 :            :   /* The block must be marked as dirty now, rather than later as in
     955                 :            :      df_insn_rescan and df_notes_rescan because it may not be there at
     956                 :            :      rescanning time and the mark would blow up.
     957                 :            :      DEBUG_INSNs do not make a block's data flow solution dirty (at
     958                 :            :      worst the LUIDs are no longer contiguous).  */
     959                 :   59940600 :   if (bb != NULL && NONDEBUG_INSN_P (insn))
     960                 :   31258700 :     df_set_bb_dirty (bb);
     961                 :            : 
     962                 :            :   /* The client has deferred rescanning.  */
     963                 :   59940600 :   if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
     964                 :            :     {
     965                 :    7615260 :       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
     966                 :    7615260 :       if (insn_info)
     967                 :            :         {
     968                 :    7615260 :           bitmap_clear_bit (&df->insns_to_rescan, uid);
     969                 :    7615260 :           bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
     970                 :    7615260 :           bitmap_set_bit (&df->insns_to_delete, uid);
     971                 :            :         }
     972                 :    7615260 :       if (dump_file)
     973                 :        799 :         fprintf (dump_file, "deferring deletion of insn with uid = %d.\n", uid);
     974                 :    7615260 :       return;
     975                 :            :     }
     976                 :            : 
     977                 :   52325400 :   if (dump_file)
     978                 :       1105 :     fprintf (dump_file, "deleting insn with uid = %d.\n", uid);
     979                 :            : 
     980                 :   52325400 :   df_insn_info_delete (uid);
     981                 :            : }
     982                 :            : 
     983                 :            : 
     984                 :            : /* Free all of the refs and the mw_hardregs in COLLECTION_REC.  */
     985                 :            : 
     986                 :            : static void
     987                 :  456889000 : df_free_collection_rec (class df_collection_rec *collection_rec)
     988                 :            : {
     989                 :  456889000 :   unsigned int ix;
     990                 :  456889000 :   struct df_scan_problem_data *problem_data
     991                 :  456889000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
     992                 :  456889000 :   df_ref ref;
     993                 :  456889000 :   struct df_mw_hardreg *mw;
     994                 :            : 
     995                 : 3011350000 :   FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
     996                 : 2554460000 :     df_free_ref (ref);
     997                 :  936267000 :   FOR_EACH_VEC_ELT (collection_rec->use_vec, ix, ref)
     998                 :  479378000 :     df_free_ref (ref);
     999                 :  466981000 :   FOR_EACH_VEC_ELT (collection_rec->eq_use_vec, ix, ref)
    1000                 :   10091700 :     df_free_ref (ref);
    1001                 :  459376000 :   FOR_EACH_VEC_ELT (collection_rec->mw_vec, ix, mw)
    1002                 :    2487260 :     problem_data->mw_reg_pool->remove (mw);
    1003                 :            : 
    1004                 :  456889000 :   collection_rec->def_vec.release ();
    1005                 :  456889000 :   collection_rec->use_vec.release ();
    1006                 :  456889000 :   collection_rec->eq_use_vec.release ();
    1007                 :  456889000 :   collection_rec->mw_vec.release ();
    1008                 :  456889000 : }
    1009                 :            : 
    1010                 :            : /* Rescan INSN.  Return TRUE if the rescanning produced any changes.  */
    1011                 :            : 
    1012                 :            : bool
    1013                 :  136127000 : df_insn_rescan (rtx_insn *insn)
    1014                 :            : {
    1015                 :  136127000 :   unsigned int uid = INSN_UID (insn);
    1016                 :  136127000 :   struct df_insn_info *insn_info = NULL;
    1017                 :  136127000 :   basic_block bb = BLOCK_FOR_INSN (insn);
    1018                 :  260760000 :   class df_collection_rec collection_rec;
    1019                 :            : 
    1020                 :  136127000 :   if ((!df) || (!INSN_P (insn)))
    1021                 :            :     return false;
    1022                 :            : 
    1023                 :  117351000 :   if (!bb)
    1024                 :            :     {
    1025                 :         80 :       if (dump_file)
    1026                 :          0 :         fprintf (dump_file, "no bb for insn with uid = %d.\n", uid);
    1027                 :         80 :       return false;
    1028                 :            :     }
    1029                 :            : 
    1030                 :            :   /* The client has disabled rescanning and plans to do it itself.  */
    1031                 :  117351000 :   if (df->changeable_flags & DF_NO_INSN_RESCAN)
    1032                 :            :     return false;
    1033                 :            : 
    1034                 :  108295000 :   df_grow_bb_info (df_scan);
    1035                 :  108295000 :   df_grow_reg_info ();
    1036                 :            : 
    1037                 :  108295000 :   insn_info = DF_INSN_UID_SAFE_GET (uid);
    1038                 :            : 
    1039                 :            :   /* The client has deferred rescanning.  */
    1040                 :  108295000 :   if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
    1041                 :            :     {
    1042                 :   25908300 :       if (!insn_info)
    1043                 :            :         {
    1044                 :    1565410 :           insn_info = df_insn_create_insn_record (insn);
    1045                 :    1565410 :           insn_info->defs = 0;
    1046                 :    1565410 :           insn_info->uses = 0;
    1047                 :    1565410 :           insn_info->eq_uses = 0;
    1048                 :    1565410 :           insn_info->mw_hardregs = 0;
    1049                 :            :         }
    1050                 :   25908300 :       if (dump_file)
    1051                 :       6498 :         fprintf (dump_file, "deferring rescan insn with uid = %d.\n", uid);
    1052                 :            : 
    1053                 :   25908300 :       bitmap_clear_bit (&df->insns_to_delete, uid);
    1054                 :   25908300 :       bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
    1055                 :   25908300 :       bitmap_set_bit (&df->insns_to_rescan, INSN_UID (insn));
    1056                 :   25908300 :       return false;
    1057                 :            :     }
    1058                 :            : 
    1059                 :   82387200 :   bitmap_clear_bit (&df->insns_to_delete, uid);
    1060                 :   82387200 :   bitmap_clear_bit (&df->insns_to_rescan, uid);
    1061                 :   82387200 :   bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
    1062                 :   82387200 :   if (insn_info)
    1063                 :            :     {
    1064                 :   60525100 :       int luid;
    1065                 :   60525100 :       bool the_same = df_insn_refs_verify (&collection_rec, bb, insn, false);
    1066                 :            :       /* If there's no change, return false. */
    1067                 :   60525100 :       if (the_same)
    1068                 :            :         {
    1069                 :   30002700 :           df_free_collection_rec (&collection_rec);
    1070                 :   30002700 :           if (dump_file)
    1071                 :       2875 :             fprintf (dump_file, "verify found no changes in insn with uid = %d.\n", uid);
    1072                 :   30002700 :           return false;
    1073                 :            :         }
    1074                 :   30522300 :       if (dump_file)
    1075                 :       4893 :         fprintf (dump_file, "rescanning insn with uid = %d.\n", uid);
    1076                 :            : 
    1077                 :            :       /* There's change - we need to delete the existing info.
    1078                 :            :          Since the insn isn't moved, we can salvage its LUID.  */
    1079                 :   30522300 :       luid = DF_INSN_LUID (insn);
    1080                 :   30522300 :       df_insn_info_free_fields (insn_info);
    1081                 :   30522300 :       df_insn_info_init_fields (insn_info, insn);
    1082                 :   30522300 :       DF_INSN_LUID (insn) = luid;
    1083                 :            :     }
    1084                 :            :   else
    1085                 :            :     {
    1086                 :   21862100 :       struct df_insn_info *insn_info = df_insn_create_insn_record (insn);
    1087                 :   21862100 :       df_insn_refs_collect (&collection_rec, bb, insn_info);
    1088                 :   21862100 :       if (dump_file)
    1089                 :       1013 :         fprintf (dump_file, "scanning new insn with uid = %d.\n", uid);
    1090                 :            :     }
    1091                 :            : 
    1092                 :   52384400 :   df_refs_add_to_chains (&collection_rec, bb, insn, copy_all);
    1093                 :   52384400 :   if (!DEBUG_INSN_P (insn))
    1094                 :   49825500 :     df_set_bb_dirty (bb);
    1095                 :            : 
    1096                 :            :   return true;
    1097                 :            : }
    1098                 :            : 
    1099                 :            : /* Same as df_insn_rescan, but don't mark the basic block as
    1100                 :            :    dirty.  */
    1101                 :            : 
    1102                 :            : bool
    1103                 :      24762 : df_insn_rescan_debug_internal (rtx_insn *insn)
    1104                 :            : {
    1105                 :      24762 :   unsigned int uid = INSN_UID (insn);
    1106                 :      24762 :   struct df_insn_info *insn_info;
    1107                 :            : 
    1108                 :      24762 :   gcc_assert (DEBUG_INSN_P (insn)
    1109                 :            :               && VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)));
    1110                 :            : 
    1111                 :      24762 :   if (!df)
    1112                 :            :     return false;
    1113                 :            : 
    1114                 :      24762 :   insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
    1115                 :      24762 :   if (!insn_info)
    1116                 :            :     return false;
    1117                 :            : 
    1118                 :      24762 :   if (dump_file)
    1119                 :          0 :     fprintf (dump_file, "deleting debug_insn with uid = %d.\n", uid);
    1120                 :            : 
    1121                 :      24762 :   bitmap_clear_bit (&df->insns_to_delete, uid);
    1122                 :      24762 :   bitmap_clear_bit (&df->insns_to_rescan, uid);
    1123                 :      24762 :   bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
    1124                 :            : 
    1125                 :      24762 :   if (insn_info->defs == 0
    1126                 :      24762 :       && insn_info->uses == 0
    1127                 :          0 :       && insn_info->eq_uses == 0
    1128                 :          0 :       && insn_info->mw_hardregs == 0)
    1129                 :            :     return false;
    1130                 :            : 
    1131                 :      24762 :   df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
    1132                 :            : 
    1133                 :      24762 :   if (df_chain)
    1134                 :            :     {
    1135                 :      14254 :       df_ref_chain_delete_du_chain (insn_info->defs);
    1136                 :      14254 :       df_ref_chain_delete_du_chain (insn_info->uses);
    1137                 :      14254 :       df_ref_chain_delete_du_chain (insn_info->eq_uses);
    1138                 :            :     }
    1139                 :            : 
    1140                 :      24762 :   df_ref_chain_delete (insn_info->defs);
    1141                 :      24762 :   df_ref_chain_delete (insn_info->uses);
    1142                 :      24762 :   df_ref_chain_delete (insn_info->eq_uses);
    1143                 :            : 
    1144                 :      24762 :   insn_info->defs = 0;
    1145                 :      24762 :   insn_info->uses = 0;
    1146                 :      24762 :   insn_info->eq_uses = 0;
    1147                 :      24762 :   insn_info->mw_hardregs = 0;
    1148                 :            : 
    1149                 :      24762 :   return true;
    1150                 :            : }
    1151                 :            : 
    1152                 :            : 
    1153                 :            : /* Rescan all of the insns in the function.  Note that the artificial
    1154                 :            :    uses and defs are not touched.  This function will destroy def-use
    1155                 :            :    or use-def chains.  */
    1156                 :            : 
    1157                 :            : void
    1158                 :          0 : df_insn_rescan_all (void)
    1159                 :            : {
    1160                 :          0 :   bool no_insn_rescan = false;
    1161                 :          0 :   bool defer_insn_rescan = false;
    1162                 :          0 :   basic_block bb;
    1163                 :          0 :   bitmap_iterator bi;
    1164                 :          0 :   unsigned int uid;
    1165                 :            : 
    1166                 :          0 :   if (df->changeable_flags & DF_NO_INSN_RESCAN)
    1167                 :            :     {
    1168                 :          0 :       df_clear_flags (DF_NO_INSN_RESCAN);
    1169                 :          0 :       no_insn_rescan = true;
    1170                 :            :     }
    1171                 :            : 
    1172                 :          0 :   if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
    1173                 :            :     {
    1174                 :          0 :       df_clear_flags (DF_DEFER_INSN_RESCAN);
    1175                 :          0 :       defer_insn_rescan = true;
    1176                 :            :     }
    1177                 :            : 
    1178                 :          0 :   auto_bitmap tmp (&df_bitmap_obstack);
    1179                 :          0 :   bitmap_copy (tmp, &df->insns_to_delete);
    1180                 :          0 :   EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
    1181                 :            :     {
    1182                 :          0 :       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
    1183                 :          0 :       if (insn_info)
    1184                 :          0 :         df_insn_info_delete (uid);
    1185                 :            :     }
    1186                 :            : 
    1187                 :          0 :   bitmap_clear (&df->insns_to_delete);
    1188                 :          0 :   bitmap_clear (&df->insns_to_rescan);
    1189                 :          0 :   bitmap_clear (&df->insns_to_notes_rescan);
    1190                 :            : 
    1191                 :          0 :   FOR_EACH_BB_FN (bb, cfun)
    1192                 :            :     {
    1193                 :          0 :       rtx_insn *insn;
    1194                 :          0 :       FOR_BB_INSNS (bb, insn)
    1195                 :            :         {
    1196                 :          0 :           df_insn_rescan (insn);
    1197                 :            :         }
    1198                 :            :     }
    1199                 :            : 
    1200                 :          0 :   if (no_insn_rescan)
    1201                 :          0 :     df_set_flags (DF_NO_INSN_RESCAN);
    1202                 :          0 :   if (defer_insn_rescan)
    1203                 :          0 :     df_set_flags (DF_DEFER_INSN_RESCAN);
    1204                 :          0 : }
    1205                 :            : 
    1206                 :            : 
    1207                 :            : /* Process all of the deferred rescans or deletions.  */
    1208                 :            : 
    1209                 :            : void
    1210                 :   48342700 : df_process_deferred_rescans (void)
    1211                 :            : {
    1212                 :   48342700 :   bool no_insn_rescan = false;
    1213                 :   48342700 :   bool defer_insn_rescan = false;
    1214                 :   48342700 :   bitmap_iterator bi;
    1215                 :   48342700 :   unsigned int uid;
    1216                 :            : 
    1217                 :   48342700 :   if (df->changeable_flags & DF_NO_INSN_RESCAN)
    1218                 :            :     {
    1219                 :          0 :       df_clear_flags (DF_NO_INSN_RESCAN);
    1220                 :          0 :       no_insn_rescan = true;
    1221                 :            :     }
    1222                 :            : 
    1223                 :   48342700 :   if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
    1224                 :            :     {
    1225                 :    6211060 :       df_clear_flags (DF_DEFER_INSN_RESCAN);
    1226                 :    6211060 :       defer_insn_rescan = true;
    1227                 :            :     }
    1228                 :            : 
    1229                 :   48342700 :   if (dump_file)
    1230                 :       3020 :     fprintf (dump_file, "starting the processing of deferred insns\n");
    1231                 :            : 
    1232                 :   48342700 :   auto_bitmap tmp (&df_bitmap_obstack);
    1233                 :   48342700 :   bitmap_copy (tmp, &df->insns_to_delete);
    1234                 :   55955700 :   EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
    1235                 :            :     {
    1236                 :   15225900 :       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
    1237                 :    7612950 :       if (insn_info)
    1238                 :    7612950 :         df_insn_info_delete (uid);
    1239                 :            :     }
    1240                 :            : 
    1241                 :   48342700 :   bitmap_copy (tmp, &df->insns_to_rescan);
    1242                 :   68983100 :   EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
    1243                 :            :     {
    1244                 :   41280800 :       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
    1245                 :   20640400 :       if (insn_info)
    1246                 :   20640400 :         df_insn_rescan (insn_info->insn);
    1247                 :            :     }
    1248                 :            : 
    1249                 :   48342700 :   bitmap_copy (tmp, &df->insns_to_notes_rescan);
    1250                 :   52921300 :   EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
    1251                 :            :     {
    1252                 :    9157090 :       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
    1253                 :    4578550 :       if (insn_info)
    1254                 :    4578550 :         df_notes_rescan (insn_info->insn);
    1255                 :            :     }
    1256                 :            : 
    1257                 :   48342700 :   if (dump_file)
    1258                 :       3020 :     fprintf (dump_file, "ending the processing of deferred insns\n");
    1259                 :            : 
    1260                 :   48342700 :   bitmap_clear (&df->insns_to_delete);
    1261                 :   48342700 :   bitmap_clear (&df->insns_to_rescan);
    1262                 :   48342700 :   bitmap_clear (&df->insns_to_notes_rescan);
    1263                 :            : 
    1264                 :   48342700 :   if (no_insn_rescan)
    1265                 :          0 :     df_set_flags (DF_NO_INSN_RESCAN);
    1266                 :   48342700 :   if (defer_insn_rescan)
    1267                 :    6211060 :     df_set_flags (DF_DEFER_INSN_RESCAN);
    1268                 :            : 
    1269                 :            :   /* If someone changed regs_ever_live during this pass, fix up the
    1270                 :            :      entry and exit blocks.  */
    1271                 :   48342700 :   if (df->redo_entry_and_exit)
    1272                 :            :     {
    1273                 :     579163 :       df_update_entry_exit_and_calls ();
    1274                 :     579163 :       df->redo_entry_and_exit = false;
    1275                 :            :     }
    1276                 :   48342700 : }
    1277                 :            : 
    1278                 :            : 
    1279                 :            : /* Count the number of refs. Include the defs if INCLUDE_DEFS. Include
    1280                 :            :    the uses if INCLUDE_USES. Include the eq_uses if
    1281                 :            :    INCLUDE_EQ_USES.  */
    1282                 :            : 
    1283                 :            : static unsigned int
    1284                 :    4256530 : df_count_refs (bool include_defs, bool include_uses,
    1285                 :            :                bool include_eq_uses)
    1286                 :            : {
    1287                 :    4256530 :   unsigned int regno;
    1288                 :    4256530 :   int size = 0;
    1289                 :    4256530 :   unsigned int m = df->regs_inited;
    1290                 :            : 
    1291                 :  700594000 :   for (regno = 0; regno < m; regno++)
    1292                 :            :     {
    1293                 :  696338000 :       if (include_defs)
    1294                 :  532795000 :         size += DF_REG_DEF_COUNT (regno);
    1295                 :  696338000 :       if (include_uses)
    1296                 :  163543000 :         size += DF_REG_USE_COUNT (regno);
    1297                 :  696338000 :       if (include_eq_uses)
    1298                 :  163543000 :         size += DF_REG_EQ_USE_COUNT (regno);
    1299                 :            :     }
    1300                 :    4256530 :   return size;
    1301                 :            : }
    1302                 :            : 
    1303                 :            : 
    1304                 :            : /* Take build ref table for either the uses or defs from the reg-use
    1305                 :            :    or reg-def chains.  This version processes the refs in reg order
    1306                 :            :    which is likely to be best if processing the whole function.  */
    1307                 :            : 
    1308                 :            : static void
    1309                 :    2493740 : df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
    1310                 :            :                                   bool include_defs,
    1311                 :            :                                   bool include_uses,
    1312                 :            :                                   bool include_eq_uses)
    1313                 :            : {
    1314                 :    2493740 :   unsigned int m = df->regs_inited;
    1315                 :    2493740 :   unsigned int regno;
    1316                 :    2493740 :   unsigned int offset = 0;
    1317                 :    2493740 :   unsigned int start;
    1318                 :            : 
    1319                 :    2493740 :   if (df->changeable_flags & DF_NO_HARD_REGS)
    1320                 :            :     {
    1321                 :      15795 :       start = FIRST_PSEUDO_REGISTER;
    1322                 :      15795 :       memset (ref_info->begin, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
    1323                 :      15795 :       memset (ref_info->count, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
    1324                 :            :     }
    1325                 :            :   else
    1326                 :            :     start = 0;
    1327                 :            : 
    1328                 :    2493740 :   ref_info->total_size
    1329                 :    2493740 :     = df_count_refs (include_defs, include_uses, include_eq_uses);
    1330                 :            : 
    1331                 :    2493740 :   df_check_and_grow_ref_info (ref_info, 1);
    1332                 :            : 
    1333                 :  309457000 :   for (regno = start; regno < m; regno++)
    1334                 :            :     {
    1335                 :  306963000 :       int count = 0;
    1336                 :  306963000 :       ref_info->begin[regno] = offset;
    1337                 :  306963000 :       if (include_defs)
    1338                 :            :         {
    1339                 :  306963000 :           df_ref ref = DF_REG_DEF_CHAIN (regno);
    1340                 : 1203380000 :           while (ref)
    1341                 :            :             {
    1342                 :  896417000 :               ref_info->refs[offset] = ref;
    1343                 :  896417000 :               DF_REF_ID (ref) = offset++;
    1344                 :  896417000 :               count++;
    1345                 :  896417000 :               ref = DF_REF_NEXT_REG (ref);
    1346                 :  896417000 :               gcc_checking_assert (offset < ref_info->refs_size);
    1347                 :            :             }
    1348                 :            :         }
    1349                 :  306963000 :       if (include_uses)
    1350                 :            :         {
    1351                 :          0 :           df_ref ref = DF_REG_USE_CHAIN (regno);
    1352                 :          0 :           while (ref)
    1353                 :            :             {
    1354                 :          0 :               ref_info->refs[offset] = ref;
    1355                 :          0 :               DF_REF_ID (ref) = offset++;
    1356                 :          0 :               count++;
    1357                 :          0 :               ref = DF_REF_NEXT_REG (ref);
    1358                 :          0 :               gcc_checking_assert (offset < ref_info->refs_size);
    1359                 :            :             }
    1360                 :            :         }
    1361                 :  306963000 :       if (include_eq_uses)
    1362                 :            :         {
    1363                 :          0 :           df_ref ref = DF_REG_EQ_USE_CHAIN (regno);
    1364                 :          0 :           while (ref)
    1365                 :            :             {
    1366                 :          0 :               ref_info->refs[offset] = ref;
    1367                 :          0 :               DF_REF_ID (ref) = offset++;
    1368                 :          0 :               count++;
    1369                 :          0 :               ref = DF_REF_NEXT_REG (ref);
    1370                 :          0 :               gcc_checking_assert (offset < ref_info->refs_size);
    1371                 :            :             }
    1372                 :            :         }
    1373                 :  306963000 :       ref_info->count[regno] = count;
    1374                 :            :     }
    1375                 :            : 
    1376                 :            :   /* The bitmap size is not decremented when refs are deleted.  So
    1377                 :            :      reset it now that we have squished out all of the empty
    1378                 :            :      slots.  */
    1379                 :    2493740 :   ref_info->table_size = offset;
    1380                 :    2493740 : }
    1381                 :            : 
    1382                 :            : 
    1383                 :            : /* Take build ref table for either the uses or defs from the reg-use
    1384                 :            :    or reg-def chains.  This version processes the refs in insn order
    1385                 :            :    which is likely to be best if processing some segment of the
    1386                 :            :    function.  */
    1387                 :            : 
    1388                 :            : static void
    1389                 :     385774 : df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
    1390                 :            :                                    bool include_defs,
    1391                 :            :                                    bool include_uses,
    1392                 :            :                                    bool include_eq_uses)
    1393                 :            : {
    1394                 :     385774 :   bitmap_iterator bi;
    1395                 :     385774 :   unsigned int bb_index;
    1396                 :     385774 :   unsigned int m = df->regs_inited;
    1397                 :     385774 :   unsigned int offset = 0;
    1398                 :     385774 :   unsigned int r;
    1399                 :     771548 :   unsigned int start
    1400                 :     385774 :     = (df->changeable_flags & DF_NO_HARD_REGS) ? FIRST_PSEUDO_REGISTER : 0;
    1401                 :            : 
    1402                 :     385774 :   memset (ref_info->begin, 0, sizeof (int) * df->regs_inited);
    1403                 :     385774 :   memset (ref_info->count, 0, sizeof (int) * df->regs_inited);
    1404                 :            : 
    1405                 :     385774 :   ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
    1406                 :     385774 :   df_check_and_grow_ref_info (ref_info, 1);
    1407                 :            : 
    1408                 :    3061650 :   EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
    1409                 :            :     {
    1410                 :    2675880 :       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
    1411                 :    2675880 :       rtx_insn *insn;
    1412                 :    2675880 :       df_ref def, use;
    1413                 :            : 
    1414                 :    2675880 :       if (include_defs)
    1415                 :    5385180 :         FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
    1416                 :            :           {
    1417                 :      33421 :             unsigned int regno = DF_REF_REGNO (def);
    1418                 :      33421 :             ref_info->count[regno]++;
    1419                 :            :           }
    1420                 :    2675880 :       if (include_uses)
    1421                 :          0 :         FOR_EACH_ARTIFICIAL_USE (use, bb_index)
    1422                 :            :           {
    1423                 :          0 :             unsigned int regno = DF_REF_REGNO (use);
    1424                 :          0 :             ref_info->count[regno]++;
    1425                 :            :           }
    1426                 :            : 
    1427                 :   62100700 :       FOR_BB_INSNS (bb, insn)
    1428                 :            :         {
    1429                 :   29712400 :           if (INSN_P (insn))
    1430                 :            :             {
    1431                 :   25263100 :               struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    1432                 :            : 
    1433                 :   25263100 :               if (include_defs)
    1434                 :   79655600 :                 FOR_EACH_INSN_INFO_DEF (def, insn_info)
    1435                 :            :                   {
    1436                 :   54392500 :                     unsigned int regno = DF_REF_REGNO (def);
    1437                 :   54392500 :                     ref_info->count[regno]++;
    1438                 :            :                   }
    1439                 :   25263100 :               if (include_uses)
    1440                 :          0 :                 FOR_EACH_INSN_INFO_USE (use, insn_info)
    1441                 :            :                   {
    1442                 :          0 :                     unsigned int regno = DF_REF_REGNO (use);
    1443                 :          0 :                     ref_info->count[regno]++;
    1444                 :            :                   }
    1445                 :   25263100 :               if (include_eq_uses)
    1446                 :          0 :                 FOR_EACH_INSN_INFO_EQ_USE (use, insn_info)
    1447                 :            :                   {
    1448                 :          0 :                     unsigned int regno = DF_REF_REGNO (use);
    1449                 :          0 :                     ref_info->count[regno]++;
    1450                 :            :                   }
    1451                 :            :             }
    1452                 :            :         }
    1453                 :            :     }
    1454                 :            : 
    1455                 :  225017000 :   for (r = start; r < m; r++)
    1456                 :            :     {
    1457                 :  224631000 :       ref_info->begin[r] = offset;
    1458                 :  224631000 :       offset += ref_info->count[r];
    1459                 :  224631000 :       ref_info->count[r] = 0;
    1460                 :            :     }
    1461                 :            : 
    1462                 :    3061650 :   EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
    1463                 :            :     {
    1464                 :    2675880 :       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
    1465                 :    2675880 :       rtx_insn *insn;
    1466                 :    2675880 :       df_ref def, use;
    1467                 :            : 
    1468                 :    2675880 :       if (include_defs)
    1469                 :    5385180 :         FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
    1470                 :            :           {
    1471                 :      33421 :             unsigned int regno = DF_REF_REGNO (def);
    1472                 :      33421 :             if (regno >= start)
    1473                 :            :               {
    1474                 :      33421 :                 unsigned int id
    1475                 :      33421 :                   = ref_info->begin[regno] + ref_info->count[regno]++;
    1476                 :      33421 :                 DF_REF_ID (def) = id;
    1477                 :      33421 :                 ref_info->refs[id] = def;
    1478                 :            :               }
    1479                 :            :           }
    1480                 :    2675880 :       if (include_uses)
    1481                 :          0 :         FOR_EACH_ARTIFICIAL_USE (use, bb_index)
    1482                 :            :           {
    1483                 :          0 :             unsigned int regno = DF_REF_REGNO (def);
    1484                 :          0 :             if (regno >= start)
    1485                 :            :               {
    1486                 :          0 :                 unsigned int id
    1487                 :          0 :                   = ref_info->begin[regno] + ref_info->count[regno]++;
    1488                 :          0 :                 DF_REF_ID (use) = id;
    1489                 :          0 :                 ref_info->refs[id] = use;
    1490                 :            :               }
    1491                 :            :           }
    1492                 :            : 
    1493                 :   62100700 :       FOR_BB_INSNS (bb, insn)
    1494                 :            :         {
    1495                 :   29712400 :           if (INSN_P (insn))
    1496                 :            :             {
    1497                 :   25263100 :               struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    1498                 :            : 
    1499                 :   25263100 :               if (include_defs)
    1500                 :   79655600 :                 FOR_EACH_INSN_INFO_DEF (def, insn_info)
    1501                 :            :                   {
    1502                 :   54392500 :                     unsigned int regno = DF_REF_REGNO (def);
    1503                 :   54392500 :                     if (regno >= start)
    1504                 :            :                       {
    1505                 :   54392500 :                         unsigned int id
    1506                 :   54392500 :                           = ref_info->begin[regno] + ref_info->count[regno]++;
    1507                 :   54392500 :                         DF_REF_ID (def) = id;
    1508                 :   54392500 :                         ref_info->refs[id] = def;
    1509                 :            :                       }
    1510                 :            :                   }
    1511                 :   25263100 :               if (include_uses)
    1512                 :          0 :                 FOR_EACH_INSN_INFO_USE (use, insn_info)
    1513                 :            :                   {
    1514                 :          0 :                     unsigned int regno = DF_REF_REGNO (use);
    1515                 :          0 :                     if (regno >= start)
    1516                 :            :                       {
    1517                 :          0 :                         unsigned int id
    1518                 :          0 :                           = ref_info->begin[regno] + ref_info->count[regno]++;
    1519                 :          0 :                         DF_REF_ID (use) = id;
    1520                 :          0 :                         ref_info->refs[id] = use;
    1521                 :            :                       }
    1522                 :            :                   }
    1523                 :   25263100 :               if (include_eq_uses)
    1524                 :          0 :                 FOR_EACH_INSN_INFO_EQ_USE (use, insn_info)
    1525                 :            :                   {
    1526                 :          0 :                     unsigned int regno = DF_REF_REGNO (use);
    1527                 :          0 :                     if (regno >= start)
    1528                 :            :                       {
    1529                 :          0 :                         unsigned int id
    1530                 :          0 :                           = ref_info->begin[regno] + ref_info->count[regno]++;
    1531                 :          0 :                         DF_REF_ID (use) = id;
    1532                 :          0 :                         ref_info->refs[id] = use;
    1533                 :            :                       }
    1534                 :            :                   }
    1535                 :            :             }
    1536                 :            :         }
    1537                 :            :     }
    1538                 :            : 
    1539                 :            :   /* The bitmap size is not decremented when refs are deleted.  So
    1540                 :            :      reset it now that we have squished out all of the empty
    1541                 :            :      slots.  */
    1542                 :            : 
    1543                 :     385774 :   ref_info->table_size = offset;
    1544                 :     385774 : }
    1545                 :            : 
    1546                 :            : /* Take build ref table for either the uses or defs from the reg-use
    1547                 :            :    or reg-def chains.  */
    1548                 :            : 
    1549                 :            : static void
    1550                 :    2879510 : df_reorganize_refs_by_reg (struct df_ref_info *ref_info,
    1551                 :            :                            bool include_defs,
    1552                 :            :                            bool include_uses,
    1553                 :            :                            bool include_eq_uses)
    1554                 :            : {
    1555                 :    2879510 :   if (df->analyze_subset)
    1556                 :     385774 :     df_reorganize_refs_by_reg_by_insn (ref_info, include_defs,
    1557                 :            :                                        include_uses, include_eq_uses);
    1558                 :            :   else
    1559                 :    2493740 :     df_reorganize_refs_by_reg_by_reg (ref_info, include_defs,
    1560                 :            :                                        include_uses, include_eq_uses);
    1561                 :    2879510 : }
    1562                 :            : 
    1563                 :            : 
    1564                 :            : /* Add the refs in REF_VEC to the table in REF_INFO starting at OFFSET.  */
    1565                 :            : static unsigned int
    1566                 :          0 : df_add_refs_to_table (unsigned int offset,
    1567                 :            :                       struct df_ref_info *ref_info,
    1568                 :            :                       df_ref ref)
    1569                 :            : {
    1570                 :  461508000 :   for (; ref; ref = DF_REF_NEXT_LOC (ref))
    1571                 :  173081000 :     if (!(df->changeable_flags & DF_NO_HARD_REGS)
    1572                 :          0 :         || (DF_REF_REGNO (ref) >= FIRST_PSEUDO_REGISTER))
    1573                 :            :       {
    1574                 :  173081000 :         ref_info->refs[offset] = ref;
    1575                 :  173081000 :         DF_REF_ID (ref) = offset++;
    1576                 :            :       }
    1577                 :          0 :   return offset;
    1578                 :            : }
    1579                 :            : 
    1580                 :            : 
    1581                 :            : /* Count the number of refs in all of the insns of BB. Include the
    1582                 :            :    defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the
    1583                 :            :    eq_uses if INCLUDE_EQ_USES.  */
    1584                 :            : 
    1585                 :            : static unsigned int
    1586                 :   16359700 : df_reorganize_refs_by_insn_bb (basic_block bb, unsigned int offset,
    1587                 :            :                                struct df_ref_info *ref_info,
    1588                 :            :                                bool include_defs, bool include_uses,
    1589                 :            :                                bool include_eq_uses)
    1590                 :            : {
    1591                 :   16359700 :   rtx_insn *insn;
    1592                 :            : 
    1593                 :   16359700 :   if (include_defs)
    1594                 :          0 :     offset = df_add_refs_to_table (offset, ref_info,
    1595                 :          0 :                                    df_get_artificial_defs (bb->index));
    1596                 :   16359700 :   if (include_uses)
    1597                 :   16359700 :     offset = df_add_refs_to_table (offset, ref_info,
    1598                 :   16359700 :                                    df_get_artificial_uses (bb->index));
    1599                 :            : 
    1600                 :  173897000 :   FOR_BB_INSNS (bb, insn)
    1601                 :  157537000 :     if (INSN_P (insn))
    1602                 :            :       {
    1603                 :  136034000 :         unsigned int uid = INSN_UID (insn);
    1604                 :  136034000 :         if (include_defs)
    1605                 :  136034000 :           offset = df_add_refs_to_table (offset, ref_info,
    1606                 :          0 :                                          DF_INSN_UID_DEFS (uid));
    1607                 :  136034000 :         if (include_uses)
    1608                 :  272067000 :           offset = df_add_refs_to_table (offset, ref_info,
    1609                 :  136034000 :                                          DF_INSN_UID_USES (uid));
    1610                 :  136034000 :         if (include_eq_uses)
    1611                 :  157537000 :           offset = df_add_refs_to_table (offset, ref_info,
    1612                 :  136034000 :                                          DF_INSN_UID_EQ_USES (uid));
    1613                 :            :       }
    1614                 :   16359700 :   return offset;
    1615                 :            : }
    1616                 :            : 
    1617                 :            : 
    1618                 :            : /* Organize the refs by insn into the table in REF_INFO.  If
    1619                 :            :    blocks_to_analyze is defined, use that set, otherwise the entire
    1620                 :            :    program.  Include the defs if INCLUDE_DEFS. Include the uses if
    1621                 :            :    INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES.  */
    1622                 :            : 
    1623                 :            : static void
    1624                 :    1377020 : df_reorganize_refs_by_insn (struct df_ref_info *ref_info,
    1625                 :            :                             bool include_defs, bool include_uses,
    1626                 :            :                             bool include_eq_uses)
    1627                 :            : {
    1628                 :    1377020 :   basic_block bb;
    1629                 :    1377020 :   unsigned int offset = 0;
    1630                 :            : 
    1631                 :    1377020 :   ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
    1632                 :    1377020 :   df_check_and_grow_ref_info (ref_info, 1);
    1633                 :    1377020 :   if (df->blocks_to_analyze)
    1634                 :            :     {
    1635                 :          0 :       bitmap_iterator bi;
    1636                 :          0 :       unsigned int index;
    1637                 :            : 
    1638                 :          0 :       EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, index, bi)
    1639                 :            :         {
    1640                 :          0 :           offset = df_reorganize_refs_by_insn_bb (BASIC_BLOCK_FOR_FN (cfun,
    1641                 :            :                                                                       index),
    1642                 :            :                                                   offset, ref_info,
    1643                 :            :                                                   include_defs, include_uses,
    1644                 :            :                                                   include_eq_uses);
    1645                 :            :         }
    1646                 :            : 
    1647                 :          0 :       ref_info->table_size = offset;
    1648                 :            :     }
    1649                 :            :   else
    1650                 :            :     {
    1651                 :   17736700 :       FOR_ALL_BB_FN (bb, cfun)
    1652                 :   16359700 :         offset = df_reorganize_refs_by_insn_bb (bb, offset, ref_info,
    1653                 :            :                                                 include_defs, include_uses,
    1654                 :            :                                                 include_eq_uses);
    1655                 :    1377020 :       ref_info->table_size = offset;
    1656                 :            :     }
    1657                 :    1377020 : }
    1658                 :            : 
    1659                 :            : 
    1660                 :            : /* If the use refs in DF are not organized, reorganize them.  */
    1661                 :            : 
    1662                 :            : void
    1663                 :   24843600 : df_maybe_reorganize_use_refs (enum df_ref_order order)
    1664                 :            : {
    1665                 :   24843600 :   if (order == df->use_info.ref_order)
    1666                 :            :     return;
    1667                 :            : 
    1668                 :    2754040 :   switch (order)
    1669                 :            :     {
    1670                 :          0 :     case DF_REF_ORDER_BY_REG:
    1671                 :          0 :       df_reorganize_refs_by_reg (&df->use_info, false, true, false);
    1672                 :          0 :       break;
    1673                 :            : 
    1674                 :          0 :     case DF_REF_ORDER_BY_REG_WITH_NOTES:
    1675                 :          0 :       df_reorganize_refs_by_reg (&df->use_info, false, true, true);
    1676                 :          0 :       break;
    1677                 :            : 
    1678                 :          0 :     case DF_REF_ORDER_BY_INSN:
    1679                 :          0 :       df_reorganize_refs_by_insn (&df->use_info, false, true, false);
    1680                 :          0 :       break;
    1681                 :            : 
    1682                 :    1377020 :     case DF_REF_ORDER_BY_INSN_WITH_NOTES:
    1683                 :    1377020 :       df_reorganize_refs_by_insn (&df->use_info, false, true, true);
    1684                 :    1377020 :       break;
    1685                 :            : 
    1686                 :    1377020 :     case DF_REF_ORDER_NO_TABLE:
    1687                 :    1377020 :       free (df->use_info.refs);
    1688                 :    1377020 :       df->use_info.refs = NULL;
    1689                 :    1377020 :       df->use_info.refs_size = 0;
    1690                 :    1377020 :       break;
    1691                 :            : 
    1692                 :          0 :     case DF_REF_ORDER_UNORDERED:
    1693                 :          0 :     case DF_REF_ORDER_UNORDERED_WITH_NOTES:
    1694                 :          0 :       gcc_unreachable ();
    1695                 :    2754040 :       break;
    1696                 :            :     }
    1697                 :            : 
    1698                 :    2754040 :   df->use_info.ref_order = order;
    1699                 :            : }
    1700                 :            : 
    1701                 :            : 
    1702                 :            : /* If the def refs in DF are not organized, reorganize them.  */
    1703                 :            : 
    1704                 :            : void
    1705                 :   26346100 : df_maybe_reorganize_def_refs (enum df_ref_order order)
    1706                 :            : {
    1707                 :   26346100 :   if (order == df->def_info.ref_order)
    1708                 :            :     return;
    1709                 :            : 
    1710                 :    5759020 :   switch (order)
    1711                 :            :     {
    1712                 :    2879510 :     case DF_REF_ORDER_BY_REG:
    1713                 :    2879510 :       df_reorganize_refs_by_reg (&df->def_info, true, false, false);
    1714                 :    2879510 :       break;
    1715                 :            : 
    1716                 :          0 :     case DF_REF_ORDER_BY_INSN:
    1717                 :          0 :       df_reorganize_refs_by_insn (&df->def_info, true, false, false);
    1718                 :          0 :       break;
    1719                 :            : 
    1720                 :    2879510 :     case DF_REF_ORDER_NO_TABLE:
    1721                 :    2879510 :       free (df->def_info.refs);
    1722                 :    2879510 :       df->def_info.refs = NULL;
    1723                 :    2879510 :       df->def_info.refs_size = 0;
    1724                 :    2879510 :       break;
    1725                 :            : 
    1726                 :          0 :     case DF_REF_ORDER_BY_INSN_WITH_NOTES:
    1727                 :          0 :     case DF_REF_ORDER_BY_REG_WITH_NOTES:
    1728                 :          0 :     case DF_REF_ORDER_UNORDERED:
    1729                 :          0 :     case DF_REF_ORDER_UNORDERED_WITH_NOTES:
    1730                 :          0 :       gcc_unreachable ();
    1731                 :    5759020 :       break;
    1732                 :            :     }
    1733                 :            : 
    1734                 :    5759020 :   df->def_info.ref_order = order;
    1735                 :            : }
    1736                 :            : 
    1737                 :            : 
    1738                 :            : /* Change all of the basic block references in INSN to use the insn's
    1739                 :            :    current basic block.  This function is called from routines that move
    1740                 :            :    instructions from one block to another.  */
    1741                 :            : 
    1742                 :            : void
    1743                 :  178363000 : df_insn_change_bb (rtx_insn *insn, basic_block new_bb)
    1744                 :            : {
    1745                 :  178363000 :   basic_block old_bb = BLOCK_FOR_INSN (insn);
    1746                 :  178363000 :   struct df_insn_info *insn_info;
    1747                 :  178363000 :   unsigned int uid = INSN_UID (insn);
    1748                 :            : 
    1749                 :  178363000 :   if (old_bb == new_bb)
    1750                 :            :     return;
    1751                 :            : 
    1752                 :  157568000 :   set_block_for_insn (insn, new_bb);
    1753                 :            : 
    1754                 :  157568000 :   if (!df)
    1755                 :            :     return;
    1756                 :            : 
    1757                 :   19335500 :   if (dump_file)
    1758                 :       6185 :     fprintf (dump_file, "changing bb of uid %d\n", uid);
    1759                 :            : 
    1760                 :   19335500 :   insn_info = DF_INSN_UID_SAFE_GET (uid);
    1761                 :   19252800 :   if (insn_info == NULL)
    1762                 :            :     {
    1763                 :    6841040 :       if (dump_file)
    1764                 :       5876 :         fprintf (dump_file, "  unscanned insn\n");
    1765                 :    6841040 :       df_insn_rescan (insn);
    1766                 :    6841040 :       return;
    1767                 :            :     }
    1768                 :            : 
    1769                 :   12494500 :   if (!INSN_P (insn))
    1770                 :            :     return;
    1771                 :            : 
    1772                 :   11162700 :   df_set_bb_dirty (new_bb);
    1773                 :   11162700 :   if (old_bb)
    1774                 :            :     {
    1775                 :   11157700 :       if (dump_file)
    1776                 :        279 :         fprintf (dump_file, "  from %d to %d\n",
    1777                 :            :                  old_bb->index, new_bb->index);
    1778                 :   11157700 :       df_set_bb_dirty (old_bb);
    1779                 :            :     }
    1780                 :            :   else
    1781                 :       5006 :     if (dump_file)
    1782                 :          0 :       fprintf (dump_file, "  to %d\n", new_bb->index);
    1783                 :            : }
    1784                 :            : 
    1785                 :            : 
    1786                 :            : /* Helper function for df_ref_change_reg_with_loc.  */
    1787                 :            : 
    1788                 :            : static void
    1789                 :   63968200 : df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df,
    1790                 :            :                               struct df_reg_info *new_df,
    1791                 :            :                               unsigned int new_regno, rtx loc)
    1792                 :            : {
    1793                 :   63968200 :   df_ref the_ref = old_df->reg_chain;
    1794                 :            : 
    1795                 :  116146000 :   while (the_ref)
    1796                 :            :     {
    1797                 :   52177400 :       if ((!DF_REF_IS_ARTIFICIAL (the_ref))
    1798                 :   52177400 :           && DF_REF_LOC (the_ref)
    1799                 :   52177400 :           && (*DF_REF_LOC (the_ref) == loc))
    1800                 :            :         {
    1801                 :   48569900 :           df_ref next_ref = DF_REF_NEXT_REG (the_ref);
    1802                 :   48569900 :           df_ref prev_ref = DF_REF_PREV_REG (the_ref);
    1803                 :   48569900 :           df_ref *ref_ptr;
    1804                 :   48569900 :           struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
    1805                 :            : 
    1806                 :   48569900 :           DF_REF_REGNO (the_ref) = new_regno;
    1807                 :   48569900 :           DF_REF_REG (the_ref) = regno_reg_rtx[new_regno];
    1808                 :            : 
    1809                 :            :           /* Pull the_ref out of the old regno chain.  */
    1810                 :   48569900 :           if (prev_ref)
    1811                 :    1253190 :             DF_REF_NEXT_REG (prev_ref) = next_ref;
    1812                 :            :           else
    1813                 :   47316700 :             old_df->reg_chain = next_ref;
    1814                 :   48569900 :           if (next_ref)
    1815                 :   16334000 :             DF_REF_PREV_REG (next_ref) = prev_ref;
    1816                 :   48569900 :           old_df->n_refs--;
    1817                 :            : 
    1818                 :            :           /* Put the ref into the new regno chain.  */
    1819                 :   48569900 :           DF_REF_PREV_REG (the_ref) = NULL;
    1820                 :   48569900 :           DF_REF_NEXT_REG (the_ref) = new_df->reg_chain;
    1821                 :   48569900 :           if (new_df->reg_chain)
    1822                 :   46111100 :             DF_REF_PREV_REG (new_df->reg_chain) = the_ref;
    1823                 :   48569900 :           new_df->reg_chain = the_ref;
    1824                 :   48569900 :           new_df->n_refs++;
    1825                 :   48569900 :           if (DF_REF_BB (the_ref))
    1826                 :   48569900 :             df_set_bb_dirty (DF_REF_BB (the_ref));
    1827                 :            : 
    1828                 :            :           /* Need to sort the record again that the ref was in because
    1829                 :            :              the regno is a sorting key.  First, find the right
    1830                 :            :              record.  */
    1831                 :   48569900 :           if (DF_REF_REG_DEF_P (the_ref))
    1832                 :   18494600 :             ref_ptr = &insn_info->defs;
    1833                 :   30075300 :           else if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
    1834                 :     995977 :             ref_ptr = &insn_info->eq_uses;
    1835                 :            :           else
    1836                 :   29079300 :             ref_ptr = &insn_info->uses;
    1837                 :   48569900 :           if (dump_file)
    1838                 :       5822 :             fprintf (dump_file, "changing reg in insn %d\n",
    1839                 :       2911 :                      DF_REF_INSN_UID (the_ref));
    1840                 :            : 
    1841                 :            :           /* Stop if we find the current reference or where the reference
    1842                 :            :              needs to be.  */
    1843                 :   51927700 :           while (*ref_ptr != the_ref && df_ref_compare (*ref_ptr, the_ref) < 0)
    1844                 :    3357820 :             ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
    1845                 :   48569900 :           if (*ref_ptr != the_ref)
    1846                 :            :             {
    1847                 :            :               /* The reference needs to be promoted up the list.  */
    1848                 :    9735210 :               df_ref next = DF_REF_NEXT_LOC (the_ref);
    1849                 :    9735210 :               DF_REF_NEXT_LOC (the_ref) = *ref_ptr;
    1850                 :    9735210 :               *ref_ptr = the_ref;
    1851                 :   20809600 :               do
    1852                 :   20809600 :                 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
    1853                 :   20809600 :               while (*ref_ptr != the_ref);
    1854                 :    9735210 :               *ref_ptr = next;
    1855                 :            :             }
    1856                 :   38834700 :           else if (DF_REF_NEXT_LOC (the_ref)
    1857                 :   38834700 :                    && df_ref_compare (the_ref, DF_REF_NEXT_LOC (the_ref)) > 0)
    1858                 :            :             {
    1859                 :            :               /* The reference needs to be demoted down the list.  */
    1860                 :          0 :               *ref_ptr = DF_REF_NEXT_LOC (the_ref);
    1861                 :          0 :               do
    1862                 :          0 :                 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
    1863                 :          0 :               while (*ref_ptr && df_ref_compare (the_ref, *ref_ptr) > 0);
    1864                 :          0 :               DF_REF_NEXT_LOC (the_ref) = *ref_ptr;
    1865                 :          0 :               *ref_ptr = the_ref;
    1866                 :            :             }
    1867                 :            : 
    1868                 :            :           the_ref = next_ref;
    1869                 :            :         }
    1870                 :            :       else
    1871                 :    3607430 :         the_ref = DF_REF_NEXT_REG (the_ref);
    1872                 :            :     }
    1873                 :   63968200 : }
    1874                 :            : 
    1875                 :            : 
    1876                 :            : /* Change the regno of register LOC to NEW_REGNO and update the df
    1877                 :            :    information accordingly.  Refs that do not match LOC are not changed
    1878                 :            :    which means that artificial refs are not changed since they have no loc.
    1879                 :            :    This call is to support the SET_REGNO macro. */
    1880                 :            : 
    1881                 :            : void
    1882                 :   21322700 : df_ref_change_reg_with_loc (rtx loc, unsigned int new_regno)
    1883                 :            : {
    1884                 :   21322700 :   unsigned int old_regno = REGNO (loc);
    1885                 :   21322700 :   if (old_regno == new_regno)
    1886                 :            :     return;
    1887                 :            : 
    1888                 :   21322700 :   if (df)
    1889                 :            :     {
    1890                 :   21322700 :       df_grow_reg_info ();
    1891                 :            : 
    1892                 :   21322700 :       df_ref_change_reg_with_loc_1 (DF_REG_DEF_GET (old_regno),
    1893                 :   21322700 :                                     DF_REG_DEF_GET (new_regno),
    1894                 :            :                                     new_regno, loc);
    1895                 :   21322700 :       df_ref_change_reg_with_loc_1 (DF_REG_USE_GET (old_regno),
    1896                 :   21322700 :                                     DF_REG_USE_GET (new_regno),
    1897                 :            :                                     new_regno, loc);
    1898                 :   21322700 :       df_ref_change_reg_with_loc_1 (DF_REG_EQ_USE_GET (old_regno),
    1899                 :   21322700 :                                     DF_REG_EQ_USE_GET (new_regno),
    1900                 :            :                                     new_regno, loc);
    1901                 :            :     }
    1902                 :   21322700 :   set_mode_and_regno (loc, GET_MODE (loc), new_regno);
    1903                 :            : }
    1904                 :            : 
    1905                 :            : 
    1906                 :            : /* Delete the mw_hardregs that point into the eq_notes.  */
    1907                 :            : 
    1908                 :            : static void
    1909                 :   14562200 : df_mw_hardreg_chain_delete_eq_uses (struct df_insn_info *insn_info)
    1910                 :            : {
    1911                 :   14562200 :   struct df_mw_hardreg **mw_ptr = &insn_info->mw_hardregs;
    1912                 :   14562200 :   struct df_scan_problem_data *problem_data
    1913                 :   14562200 :     = (struct df_scan_problem_data *) df_scan->problem_data;
    1914                 :            : 
    1915                 :   14578000 :   while (*mw_ptr)
    1916                 :            :     {
    1917                 :      15728 :       df_mw_hardreg *mw = *mw_ptr;
    1918                 :      15728 :       if (mw->flags & DF_REF_IN_NOTE)
    1919                 :            :         {
    1920                 :          1 :           *mw_ptr = DF_MWS_NEXT (mw);
    1921                 :   14578000 :           problem_data->mw_reg_pool->remove (mw);
    1922                 :            :         }
    1923                 :            :       else
    1924                 :      15727 :         mw_ptr = &DF_MWS_NEXT (mw);
    1925                 :            :     }
    1926                 :   14562200 : }
    1927                 :            : 
    1928                 :            : 
    1929                 :            : /* Rescan only the REG_EQUIV/REG_EQUAL notes part of INSN.  */
    1930                 :            : 
    1931                 :            : void
    1932                 :   32066100 : df_notes_rescan (rtx_insn *insn)
    1933                 :            : {
    1934                 :   32066100 :   struct df_insn_info *insn_info;
    1935                 :   32066100 :   unsigned int uid = INSN_UID (insn);
    1936                 :            : 
    1937                 :   32066100 :   if (!df)
    1938                 :            :     return;
    1939                 :            : 
    1940                 :            :   /* The client has disabled rescanning and plans to do it itself.  */
    1941                 :   29248700 :   if (df->changeable_flags & DF_NO_INSN_RESCAN)
    1942                 :            :     return;
    1943                 :            : 
    1944                 :            :   /* Do nothing if the insn hasn't been emitted yet.  */
    1945                 :   29205900 :   if (!BLOCK_FOR_INSN (insn))
    1946                 :            :     return;
    1947                 :            : 
    1948                 :   29194100 :   df_grow_bb_info (df_scan);
    1949                 :   29194100 :   df_grow_reg_info ();
    1950                 :            : 
    1951                 :   29194100 :   insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
    1952                 :            : 
    1953                 :            :   /* The client has deferred rescanning.  */
    1954                 :   29194100 :   if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
    1955                 :            :     {
    1956                 :   14631800 :       if (!insn_info)
    1957                 :            :         {
    1958                 :          0 :           insn_info = df_insn_create_insn_record (insn);
    1959                 :          0 :           insn_info->defs = 0;
    1960                 :          0 :           insn_info->uses = 0;
    1961                 :          0 :           insn_info->eq_uses = 0;
    1962                 :          0 :           insn_info->mw_hardregs = 0;
    1963                 :            :         }
    1964                 :            : 
    1965                 :   14631800 :       bitmap_clear_bit (&df->insns_to_delete, uid);
    1966                 :            :       /* If the insn is set to be rescanned, it does not need to also
    1967                 :            :          be notes rescanned.  */
    1968                 :   14631800 :       if (!bitmap_bit_p (&df->insns_to_rescan, uid))
    1969                 :   11539100 :         bitmap_set_bit (&df->insns_to_notes_rescan, INSN_UID (insn));
    1970                 :   14631800 :       return;
    1971                 :            :     }
    1972                 :            : 
    1973                 :   14562200 :   bitmap_clear_bit (&df->insns_to_delete, uid);
    1974                 :   14562200 :   bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
    1975                 :            : 
    1976                 :   14562200 :   if (insn_info)
    1977                 :            :     {
    1978                 :   14562200 :       basic_block bb = BLOCK_FOR_INSN (insn);
    1979                 :   14562200 :       rtx note;
    1980                 :   29124500 :       class df_collection_rec collection_rec;
    1981                 :   14562200 :       unsigned int i;
    1982                 :            : 
    1983                 :   14562200 :       df_mw_hardreg_chain_delete_eq_uses (insn_info);
    1984                 :   14562200 :       df_ref_chain_delete (insn_info->eq_uses);
    1985                 :   14562200 :       insn_info->eq_uses = NULL;
    1986                 :            : 
    1987                 :            :       /* Process REG_EQUIV/REG_EQUAL notes */
    1988                 :   36258200 :       for (note = REG_NOTES (insn); note;
    1989                 :   21696000 :            note = XEXP (note, 1))
    1990                 :            :         {
    1991                 :   21696000 :           switch (REG_NOTE_KIND (note))
    1992                 :            :             {
    1993                 :   11693900 :             case REG_EQUIV:
    1994                 :   11693900 :             case REG_EQUAL:
    1995                 :   11693900 :               df_uses_record (&collection_rec,
    1996                 :            :                               &XEXP (note, 0), DF_REF_REG_USE,
    1997                 :            :                               bb, insn_info, DF_REF_IN_NOTE);
    1998                 :   21696000 :             default:
    1999                 :   21696000 :               break;
    2000                 :            :             }
    2001                 :            :         }
    2002                 :            : 
    2003                 :            :       /* Find some place to put any new mw_hardregs.  */
    2004                 :   14562200 :       df_canonize_collection_rec (&collection_rec);
    2005                 :   14562200 :       struct df_mw_hardreg **mw_ptr = &insn_info->mw_hardregs, *mw;
    2006                 :   14562200 :       FOR_EACH_VEC_ELT (collection_rec.mw_vec, i, mw)
    2007                 :            :         {
    2008                 :          0 :           while (*mw_ptr && df_mw_compare (*mw_ptr, mw) < 0)
    2009                 :          0 :             mw_ptr = &DF_MWS_NEXT (*mw_ptr);
    2010                 :          0 :           DF_MWS_NEXT (mw) = *mw_ptr;
    2011                 :          0 :           *mw_ptr = mw;
    2012                 :          0 :           mw_ptr = &DF_MWS_NEXT (mw);
    2013                 :            :         }
    2014                 :   14562200 :       df_refs_add_to_chains (&collection_rec, bb, insn, copy_eq_uses);
    2015                 :            :     }
    2016                 :            :   else
    2017                 :          0 :     df_insn_rescan (insn);
    2018                 :            : 
    2019                 :            : }
    2020                 :            : 
    2021                 :            : 
    2022                 :            : /*----------------------------------------------------------------------------
    2023                 :            :    Hard core instruction scanning code.  No external interfaces here,
    2024                 :            :    just a lot of routines that look inside insns.
    2025                 :            : ----------------------------------------------------------------------------*/
    2026                 :            : 
    2027                 :            : 
    2028                 :            : /* Return true if the contents of two df_ref's are identical.
    2029                 :            :    It ignores DF_REF_MARKER.  */
    2030                 :            : 
    2031                 :            : static bool
    2032                 : 3351720000 : df_ref_equal_p (df_ref ref1, df_ref ref2)
    2033                 :            : {
    2034                 : 3351720000 :   if (!ref2)
    2035                 :            :     return false;
    2036                 :            : 
    2037                 : 3351720000 :   if (ref1 == ref2)
    2038                 :            :     return true;
    2039                 :            : 
    2040                 : 3351720000 :   if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2)
    2041                 : 3351720000 :       || DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2)
    2042                 : 3094980000 :       || DF_REF_REG (ref1) != DF_REF_REG (ref2)
    2043                 : 3094780000 :       || DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2)
    2044                 : 3091650000 :       || ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
    2045                 : 3091650000 :           != (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
    2046                 : 3090070000 :       || DF_REF_BB (ref1) != DF_REF_BB (ref2)
    2047                 : 6441780000 :       || DF_REF_INSN_INFO (ref1) != DF_REF_INSN_INFO (ref2))
    2048                 :            :     return false;
    2049                 :            : 
    2050                 : 3090070000 :   switch (DF_REF_CLASS (ref1))
    2051                 :            :     {
    2052                 :            :     case DF_REF_ARTIFICIAL:
    2053                 :            :     case DF_REF_BASE:
    2054                 :            :       return true;
    2055                 :            : 
    2056                 :  577466000 :     case DF_REF_REGULAR:
    2057                 :  577466000 :       return DF_REF_LOC (ref1) == DF_REF_LOC (ref2);
    2058                 :            : 
    2059                 :          0 :     default:
    2060                 :          0 :       gcc_unreachable ();
    2061                 :            :     }
    2062                 :            :   return false;
    2063                 :            : }
    2064                 :            : 
    2065                 :            : 
    2066                 :            : /* Compare REF1 and REF2 for sorting.  This is only called from places
    2067                 :            :    where all of the refs are of the same type, in the same insn, and
    2068                 :            :    have the same bb.  So these fields are not checked.  */
    2069                 :            : 
    2070                 :            : static int
    2071                 : 4282320000 : df_ref_compare (df_ref ref1, df_ref ref2)
    2072                 :            : {
    2073                 : 4282320000 :   if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2))
    2074                 :  284796000 :     return (int)DF_REF_CLASS (ref1) - (int)DF_REF_CLASS (ref2);
    2075                 :            : 
    2076                 : 3997520000 :   if (DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2))
    2077                 : 3960060000 :     return (int)DF_REF_REGNO (ref1) - (int)DF_REF_REGNO (ref2);
    2078                 :            : 
    2079                 :   37463100 :   if (DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2))
    2080                 :    6725340 :     return (int)DF_REF_TYPE (ref1) - (int)DF_REF_TYPE (ref2);
    2081                 :            : 
    2082                 :   30737700 :   if (DF_REF_REG (ref1) != DF_REF_REG (ref2))
    2083                 :     447903 :     return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
    2084                 :            : 
    2085                 :            :   /* Cannot look at the LOC field on artificial refs.  */
    2086                 :   30289800 :   if (DF_REF_CLASS (ref1) != DF_REF_ARTIFICIAL
    2087                 :   30289800 :       && DF_REF_LOC (ref1) != DF_REF_LOC (ref2))
    2088                 :   20665100 :     return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
    2089                 :            : 
    2090                 :    9624760 :   if (DF_REF_FLAGS (ref1) != DF_REF_FLAGS (ref2))
    2091                 :            :     {
    2092                 :            :       /* If two refs are identical except that one of them has is from
    2093                 :            :          a mw and one is not, we need to have the one with the mw
    2094                 :            :          first.  */
    2095                 :    7843110 :       if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG) ==
    2096                 :    7843110 :           DF_REF_FLAGS_IS_SET (ref2, DF_REF_MW_HARDREG))
    2097                 :    7843110 :         return DF_REF_FLAGS (ref1) - DF_REF_FLAGS (ref2);
    2098                 :          0 :       else if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG))
    2099                 :            :         return -1;
    2100                 :            :       else
    2101                 :          0 :         return 1;
    2102                 :            :     }
    2103                 :            : 
    2104                 :    1781650 :   return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
    2105                 :            : }
    2106                 :            : 
    2107                 :            : /* Like df_ref_compare, but compare two df_ref* pointers R1 and R2.  */
    2108                 :            : 
    2109                 :            : static int
    2110                 : 1001520000 : df_ref_ptr_compare (const void *r1, const void *r2)
    2111                 :            : {
    2112                 : 1001520000 :   return df_ref_compare (*(const df_ref *) r1, *(const df_ref *) r2);
    2113                 :            : }
    2114                 :            : 
    2115                 :            : /* Sort and compress a set of refs.  */
    2116                 :            : 
    2117                 :            : static void
    2118                 : 2182470000 : df_sort_and_compress_refs (vec<df_ref, va_heap> *ref_vec)
    2119                 :            : {
    2120                 : 2182470000 :   unsigned int count;
    2121                 : 2182470000 :   unsigned int i;
    2122                 : 2182470000 :   unsigned int dist = 0;
    2123                 :            : 
    2124                 : 2182470000 :   count = ref_vec->length ();
    2125                 :            : 
    2126                 :            :   /* If there are 1 or 0 elements, there is nothing to do.  */
    2127                 : 2182470000 :   if (count < 2)
    2128                 :            :     return;
    2129                 :  275797000 :   else if (count == 2)
    2130                 :            :     {
    2131                 :  161759000 :       df_ref r0 = (*ref_vec)[0];
    2132                 :  161759000 :       df_ref r1 = (*ref_vec)[1];
    2133                 :  161759000 :       if (df_ref_compare (r0, r1) > 0)
    2134                 :   62398600 :         std::swap ((*ref_vec)[0], (*ref_vec)[1]);
    2135                 :            :     }
    2136                 :            :   else
    2137                 :            :     {
    2138                 : 3186060000 :       for (i = 0; i < count - 1; i++)
    2139                 :            :         {
    2140                 : 3097710000 :           df_ref r0 = (*ref_vec)[i];
    2141                 : 3097710000 :           df_ref r1 = (*ref_vec)[i + 1];
    2142                 : 3097710000 :           if (df_ref_compare (r0, r1) >= 0)
    2143                 :            :             break;
    2144                 :            :         }
    2145                 :            :       /* If the array is already strictly ordered,
    2146                 :            :          which is the most common case for large COUNT case
    2147                 :            :          (which happens for CALL INSNs),
    2148                 :            :          no need to sort and filter out duplicate.
    2149                 :            :          Simply return the count.
    2150                 :            :          Make sure DF_GET_ADD_REFS adds refs in the increasing order
    2151                 :            :          of DF_REF_COMPARE.  */
    2152                 :  114038000 :       if (i == count - 1)
    2153                 :            :         return;
    2154                 :   25690100 :       ref_vec->qsort (df_ref_ptr_compare);
    2155                 :            :     }
    2156                 :            : 
    2157                 :  625554000 :   for (i=0; i<count-dist; i++)
    2158                 :            :     {
    2159                 :            :       /* Find the next ref that is not equal to the current ref.  */
    2160                 :  438281000 :       while (i + dist + 1 < count
    2161                 :  689112000 :              && df_ref_equal_p ((*ref_vec)[i],
    2162                 :  250831000 :                                 (*ref_vec)[i + dist + 1]))
    2163                 :            :         {
    2164                 :     175857 :           df_free_ref ((*ref_vec)[i + dist + 1]);
    2165                 :     175857 :           dist++;
    2166                 :            :         }
    2167                 :            :       /* Copy it down to the next position.  */
    2168                 :  438105000 :       if (dist && i + dist + 1 < count)
    2169                 :      47012 :         (*ref_vec)[i + 1] = (*ref_vec)[i + dist + 1];
    2170                 :            :     }
    2171                 :            : 
    2172                 :  187449000 :   count -= dist;
    2173                 :  187449000 :   ref_vec->truncate (count);
    2174                 :            : }
    2175                 :            : 
    2176                 :            : 
    2177                 :            : /* Return true if the contents of two df_ref's are identical.
    2178                 :            :    It ignores DF_REF_MARKER.  */
    2179                 :            : 
    2180                 :            : static bool
    2181                 :    2935070 : df_mw_equal_p (struct df_mw_hardreg *mw1, struct df_mw_hardreg *mw2)
    2182                 :            : {
    2183                 :          0 :   if (!mw2)
    2184                 :            :     return false;
    2185                 :     447812 :   return (mw1 == mw2) ||
    2186                 :    2935070 :     (mw1->mw_reg == mw2->mw_reg
    2187                 :            :      && mw1->type == mw2->type
    2188                 :            :      && mw1->flags == mw2->flags
    2189                 :    2600390 :      && mw1->start_regno == mw2->start_regno
    2190                 :    2509760 :      && mw1->end_regno == mw2->end_regno);
    2191                 :            : }
    2192                 :            : 
    2193                 :            : 
    2194                 :            : /* Compare MW1 and MW2 for sorting.  */
    2195                 :            : 
    2196                 :            : static int
    2197                 :    1151420 : df_mw_compare (const df_mw_hardreg *mw1, const df_mw_hardreg *mw2)
    2198                 :            : {
    2199                 :          0 :   if (mw1->type != mw2->type)
    2200                 :     689742 :     return mw1->type - mw2->type;
    2201                 :            : 
    2202                 :     461681 :   if (mw1->flags != mw2->flags)
    2203                 :      31956 :     return mw1->flags - mw2->flags;
    2204                 :            : 
    2205                 :     429725 :   if (mw1->start_regno != mw2->start_regno)
    2206                 :     316773 :     return mw1->start_regno - mw2->start_regno;
    2207                 :            : 
    2208                 :     112952 :   if (mw1->end_regno != mw2->end_regno)
    2209                 :          0 :     return mw1->end_regno - mw2->end_regno;
    2210                 :            : 
    2211                 :     112952 :   return mw1->mw_order - mw2->mw_order;
    2212                 :            : }
    2213                 :            : 
    2214                 :            : /* Like df_mw_compare, but compare two df_mw_hardreg** pointers R1 and R2.  */
    2215                 :            : 
    2216                 :            : static int
    2217                 :     828365 : df_mw_ptr_compare (const void *m1, const void *m2)
    2218                 :            : {
    2219                 :     828365 :   return df_mw_compare (*(const df_mw_hardreg *const *) m1,
    2220                 :     828365 :                         *(const df_mw_hardreg *const *) m2);
    2221                 :            : }
    2222                 :            : 
    2223                 :            : /* Sort and compress a set of refs.  */
    2224                 :            : 
    2225                 :            : static void
    2226                 :  727489000 : df_sort_and_compress_mws (vec<df_mw_hardreg *, va_heap> *mw_vec)
    2227                 :            : {
    2228                 :  727489000 :   unsigned int count;
    2229                 :  727489000 :   struct df_scan_problem_data *problem_data
    2230                 :  727489000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
    2231                 :  727489000 :   unsigned int i;
    2232                 :  727489000 :   unsigned int dist = 0;
    2233                 :            : 
    2234                 :  727489000 :   count = mw_vec->length ();
    2235                 :  727489000 :   if (count < 2)
    2236                 :            :     return;
    2237                 :     373225 :   else if (count == 2)
    2238                 :            :     {
    2239                 :     323058 :       struct df_mw_hardreg *m0 = (*mw_vec)[0];
    2240                 :     323058 :       struct df_mw_hardreg *m1 = (*mw_vec)[1];
    2241                 :     646116 :       if (df_mw_compare (m0, m1) > 0)
    2242                 :            :         {
    2243                 :      46944 :           struct df_mw_hardreg *tmp = (*mw_vec)[0];
    2244                 :      46944 :           (*mw_vec)[0] = (*mw_vec)[1];
    2245                 :      46944 :           (*mw_vec)[1] = tmp;
    2246                 :            :         }
    2247                 :            :     }
    2248                 :            :   else
    2249                 :      50167 :     mw_vec->qsort (df_mw_ptr_compare);
    2250                 :            : 
    2251                 :    1171760 :   for (i=0; i<count-dist; i++)
    2252                 :            :     {
    2253                 :            :       /* Find the next ref that is not equal to the current ref.  */
    2254                 :     821037 :       while (i + dist + 1 < count
    2255                 :     821037 :              && df_mw_equal_p ((*mw_vec)[i], (*mw_vec)[i + dist + 1]))
    2256                 :            :         {
    2257                 :      22502 :           problem_data->mw_reg_pool->remove ((*mw_vec)[i + dist + 1]);
    2258                 :      22502 :           dist++;
    2259                 :            :         }
    2260                 :            :       /* Copy it down to the next position.  */
    2261                 :     798535 :       if (dist && i + dist + 1 < count)
    2262                 :       4698 :         (*mw_vec)[i + 1] = (*mw_vec)[i + dist + 1];
    2263                 :            :     }
    2264                 :            : 
    2265                 :     373225 :   count -= dist;
    2266                 :     373225 :   mw_vec->truncate (count);
    2267                 :            : }
    2268                 :            : 
    2269                 :            : 
    2270                 :            : /* Sort and remove duplicates from the COLLECTION_REC.  */
    2271                 :            : 
    2272                 :            : static void
    2273                 :  727489000 : df_canonize_collection_rec (class df_collection_rec *collection_rec)
    2274                 :            : {
    2275                 :  727489000 :   df_sort_and_compress_refs (&collection_rec->def_vec);
    2276                 :  727489000 :   df_sort_and_compress_refs (&collection_rec->use_vec);
    2277                 :  727489000 :   df_sort_and_compress_refs (&collection_rec->eq_use_vec);
    2278                 :  727489000 :   df_sort_and_compress_mws (&collection_rec->mw_vec);
    2279                 :  727489000 : }
    2280                 :            : 
    2281                 :            : 
    2282                 :            : /* Add the new df_ref to appropriate reg_info/ref_info chains.  */
    2283                 :            : 
    2284                 :            : static void
    2285                 : 1054780000 : df_install_ref (df_ref this_ref,
    2286                 :            :                 struct df_reg_info *reg_info,
    2287                 :            :                 struct df_ref_info *ref_info,
    2288                 :            :                 bool add_to_table)
    2289                 :            : {
    2290                 : 1054780000 :   unsigned int regno = DF_REF_REGNO (this_ref);
    2291                 :            :   /* Add the ref to the reg_{def,use,eq_use} chain.  */
    2292                 : 1054780000 :   df_ref head = reg_info->reg_chain;
    2293                 :            : 
    2294                 : 1054780000 :   reg_info->reg_chain = this_ref;
    2295                 : 1054780000 :   reg_info->n_refs++;
    2296                 :            : 
    2297                 : 1054780000 :   if (DF_REF_FLAGS_IS_SET (this_ref, DF_HARD_REG_LIVE))
    2298                 :            :     {
    2299                 :  215471000 :       gcc_assert (regno < FIRST_PSEUDO_REGISTER);
    2300                 :  215471000 :       df->hard_regs_live_count[regno]++;
    2301                 :            :     }
    2302                 :            : 
    2303                 : 1054780000 :   gcc_checking_assert (DF_REF_NEXT_REG (this_ref) == NULL
    2304                 :            :                        && DF_REF_PREV_REG (this_ref) == NULL);
    2305                 :            : 
    2306                 : 1054780000 :   DF_REF_NEXT_REG (this_ref) = head;
    2307                 :            : 
    2308                 :            :   /* We cannot actually link to the head of the chain.  */
    2309                 : 1054780000 :   DF_REF_PREV_REG (this_ref) = NULL;
    2310                 :            : 
    2311                 : 1054780000 :   if (head)
    2312                 :  860577000 :     DF_REF_PREV_REG (head) = this_ref;
    2313                 :            : 
    2314                 : 1054780000 :   if (add_to_table)
    2315                 :            :     {
    2316                 :    2885630 :       gcc_assert (ref_info->ref_order != DF_REF_ORDER_NO_TABLE);
    2317                 :    2885630 :       df_check_and_grow_ref_info (ref_info, 1);
    2318                 :    2885630 :       DF_REF_ID (this_ref) = ref_info->table_size;
    2319                 :            :       /* Add the ref to the big array of defs.  */
    2320                 :    2885630 :       ref_info->refs[ref_info->table_size] = this_ref;
    2321                 :    2885630 :       ref_info->table_size++;
    2322                 :            :     }
    2323                 :            :   else
    2324                 : 1051900000 :     DF_REF_ID (this_ref) = -1;
    2325                 :            : 
    2326                 : 1054780000 :   ref_info->total_size++;
    2327                 : 1054780000 : }
    2328                 :            : 
    2329                 :            : 
    2330                 :            : /* This function takes one of the groups of refs (defs, uses or
    2331                 :            :    eq_uses) and installs the entire group into the insn.  It also adds
    2332                 :            :    each of these refs into the appropriate chains.  */
    2333                 :            : 
    2334                 :            : static df_ref
    2335                 :  754258000 : df_install_refs (basic_block bb,
    2336                 :            :                  const vec<df_ref, va_heap> *old_vec,
    2337                 :            :                  struct df_reg_info **reg_info,
    2338                 :            :                  struct df_ref_info *ref_info,
    2339                 :            :                  bool is_notes)
    2340                 :            : {
    2341                 :  754258000 :   unsigned int count = old_vec->length ();
    2342                 :  754258000 :   if (count)
    2343                 :            :     {
    2344                 :  308952000 :       bool add_to_table;
    2345                 :  308952000 :       df_ref this_ref;
    2346                 :  308952000 :       unsigned int ix;
    2347                 :            : 
    2348                 :  308952000 :       switch (ref_info->ref_order)
    2349                 :            :         {
    2350                 :          0 :         case DF_REF_ORDER_UNORDERED_WITH_NOTES:
    2351                 :          0 :         case DF_REF_ORDER_BY_REG_WITH_NOTES:
    2352                 :          0 :         case DF_REF_ORDER_BY_INSN_WITH_NOTES:
    2353                 :          0 :           ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
    2354                 :          0 :           add_to_table = true;
    2355                 :          0 :           break;
    2356                 :    1032600 :         case DF_REF_ORDER_UNORDERED:
    2357                 :    1032600 :         case DF_REF_ORDER_BY_REG:
    2358                 :    1032600 :         case DF_REF_ORDER_BY_INSN:
    2359                 :    1032600 :           ref_info->ref_order = DF_REF_ORDER_UNORDERED;
    2360                 :    1032600 :           add_to_table = !is_notes;
    2361                 :    1032600 :           break;
    2362                 :            :         default:
    2363                 :            :           add_to_table = false;
    2364                 :            :           break;
    2365                 :            :         }
    2366                 :            : 
    2367                 :            :       /* Do not add if ref is not in the right blocks.  */
    2368                 :    1032600 :       if (add_to_table && df->analyze_subset)
    2369                 :     831371 :         add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
    2370                 :            : 
    2371                 : 1361350000 :       FOR_EACH_VEC_ELT (*old_vec, ix, this_ref)
    2372                 :            :         {
    2373                 : 1052400000 :           DF_REF_NEXT_LOC (this_ref) = (ix + 1 < old_vec->length ()
    2374                 : 1052400000 :                                         ? (*old_vec)[ix + 1]
    2375                 :            :                                         : NULL);
    2376                 : 1052400000 :           df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)],
    2377                 :            :                           ref_info, add_to_table);
    2378                 :            :         }
    2379                 :  308952000 :       return (*old_vec)[0];
    2380                 :            :     }
    2381                 :            :   else
    2382                 :            :     return 0;
    2383                 :            : }
    2384                 :            : 
    2385                 :            : 
    2386                 :            : /* This function takes the mws installs the entire group into the
    2387                 :            :    insn.  */
    2388                 :            : 
    2389                 :            : static struct df_mw_hardreg *
    2390                 :  227620000 : df_install_mws (const vec<df_mw_hardreg *, va_heap> *old_vec)
    2391                 :            : {
    2392                 :  227620000 :   unsigned int count = old_vec->length ();
    2393                 :  227620000 :   if (count)
    2394                 :            :     {
    2395                 :    1334130 :       for (unsigned int i = 0; i < count - 1; i++)
    2396                 :     166966 :         DF_MWS_NEXT ((*old_vec)[i]) = (*old_vec)[i + 1];
    2397                 :    1167170 :       DF_MWS_NEXT ((*old_vec)[count - 1]) = 0;
    2398                 :    1167170 :       return (*old_vec)[0];
    2399                 :            :     }
    2400                 :            :   else
    2401                 :            :     return 0;
    2402                 :            : }
    2403                 :            : 
    2404                 :            : 
    2405                 :            : /* Add a chain of df_refs to appropriate ref chain/reg_info/ref_info
    2406                 :            :    chains and update other necessary information.  */
    2407                 :            : 
    2408                 :            : static void
    2409                 :  270600000 : df_refs_add_to_chains (class df_collection_rec *collection_rec,
    2410                 :            :                        basic_block bb, rtx_insn *insn, unsigned int flags)
    2411                 :            : {
    2412                 :  270600000 :   if (insn)
    2413                 :            :     {
    2414                 :  242182000 :       struct df_insn_info *insn_rec = DF_INSN_INFO_GET (insn);
    2415                 :            :       /* If there is a vector in the collection rec, add it to the
    2416                 :            :          insn.  A null rec is a signal that the caller will handle the
    2417                 :            :          chain specially.  */
    2418                 :  242182000 :       if (flags & copy_defs)
    2419                 :            :         {
    2420                 :  227620000 :           gcc_checking_assert (!insn_rec->defs);
    2421                 :  227620000 :           insn_rec->defs
    2422                 :  227620000 :             = df_install_refs (bb, &collection_rec->def_vec,
    2423                 :            :                                df->def_regs,
    2424                 :            :                                &df->def_info, false);
    2425                 :            :         }
    2426                 :  242182000 :       if (flags & copy_uses)
    2427                 :            :         {
    2428                 :  227620000 :           gcc_checking_assert (!insn_rec->uses);
    2429                 :  227620000 :           insn_rec->uses
    2430                 :  227620000 :             = df_install_refs (bb, &collection_rec->use_vec,
    2431                 :            :                                df->use_regs,
    2432                 :  227620000 :                                &df->use_info, false);
    2433                 :            :         }
    2434                 :  242182000 :       if (flags & copy_eq_uses)
    2435                 :            :         {
    2436                 :  242182000 :           gcc_checking_assert (!insn_rec->eq_uses);
    2437                 :  242182000 :           insn_rec->eq_uses
    2438                 :  242182000 :             = df_install_refs (bb, &collection_rec->eq_use_vec,
    2439                 :            :                                df->eq_use_regs,
    2440                 :  242182000 :                                &df->use_info, true);
    2441                 :            :         }
    2442                 :  242182000 :       if (flags & copy_mw)
    2443                 :            :         {
    2444                 :  227620000 :           gcc_checking_assert (!insn_rec->mw_hardregs);
    2445                 :  227620000 :           insn_rec->mw_hardregs
    2446                 :  227620000 :             = df_install_mws (&collection_rec->mw_vec);
    2447                 :            :         }
    2448                 :            :     }
    2449                 :            :   else
    2450                 :            :     {
    2451                 :   28418400 :       struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
    2452                 :            : 
    2453                 :   28418400 :       gcc_checking_assert (!bb_info->artificial_defs);
    2454                 :   28418400 :       bb_info->artificial_defs
    2455                 :   28418400 :         = df_install_refs (bb, &collection_rec->def_vec,
    2456                 :            :                            df->def_regs,
    2457                 :            :                            &df->def_info, false);
    2458                 :   28418400 :       gcc_checking_assert (!bb_info->artificial_uses);
    2459                 :   28418400 :       bb_info->artificial_uses
    2460                 :   28418400 :         = df_install_refs (bb, &collection_rec->use_vec,
    2461                 :            :                            df->use_regs,
    2462                 :   28418400 :                            &df->use_info, false);
    2463                 :            :     }
    2464                 :  270600000 : }
    2465                 :            : 
    2466                 :            : 
    2467                 :            : /* Allocate a ref and initialize its fields.  */
    2468                 :            : 
    2469                 :            : static df_ref
    2470                 : 4098880000 : df_ref_create_structure (enum df_ref_class cl,
    2471                 :            :                          class df_collection_rec *collection_rec,
    2472                 :            :                          rtx reg, rtx *loc,
    2473                 :            :                          basic_block bb, struct df_insn_info *info,
    2474                 :            :                          enum df_ref_type ref_type,
    2475                 :            :                          int ref_flags)
    2476                 :            : {
    2477                 : 4098880000 :   df_ref this_ref = NULL;
    2478                 : 4098880000 :   unsigned int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
    2479                 : 4098880000 :   struct df_scan_problem_data *problem_data
    2480                 : 4098880000 :     = (struct df_scan_problem_data *) df_scan->problem_data;
    2481                 :            : 
    2482                 : 4098880000 :   switch (cl)
    2483                 :            :     {
    2484                 : 2911200000 :     case DF_REF_BASE:
    2485                 : 2911200000 :       this_ref = (df_ref) (problem_data->ref_base_pool->allocate ());
    2486                 : 2911200000 :       gcc_checking_assert (loc == NULL);
    2487                 :            :       break;
    2488                 :            : 
    2489                 :  299466000 :     case DF_REF_ARTIFICIAL:
    2490                 :  299466000 :       this_ref = (df_ref) (problem_data->ref_artificial_pool->allocate ());
    2491                 :  299466000 :       this_ref->artificial_ref.bb = bb;
    2492                 :  299466000 :       gcc_checking_assert (loc == NULL);
    2493                 :            :       break;
    2494                 :            : 
    2495                 :  888214000 :     case DF_REF_REGULAR:
    2496                 :  888214000 :       this_ref = (df_ref) (problem_data->ref_regular_pool->allocate ());
    2497                 :  888214000 :       this_ref->regular_ref.loc = loc;
    2498                 :  888214000 :       gcc_checking_assert (loc);
    2499                 :            :       break;
    2500                 :            :     }
    2501                 :            : 
    2502                 : 4098880000 :   DF_REF_CLASS (this_ref) = cl;
    2503                 : 4098880000 :   DF_REF_ID (this_ref) = -1;
    2504                 : 4098880000 :   DF_REF_REG (this_ref) = reg;
    2505                 : 4098880000 :   DF_REF_REGNO (this_ref) =  regno;
    2506                 : 4098880000 :   DF_REF_TYPE (this_ref) = ref_type;
    2507                 : 4098880000 :   DF_REF_INSN_INFO (this_ref) = info;
    2508                 : 4098880000 :   DF_REF_CHAIN (this_ref) = NULL;
    2509                 : 4098880000 :   DF_REF_FLAGS (this_ref) = ref_flags;
    2510                 : 4098880000 :   DF_REF_NEXT_REG (this_ref) = NULL;
    2511                 : 4098880000 :   DF_REF_PREV_REG (this_ref) = NULL;
    2512                 : 4098880000 :   DF_REF_ORDER (this_ref) = df->ref_order++;
    2513                 :            : 
    2514                 :            :   /* We need to clear this bit because fwprop, and in the future
    2515                 :            :      possibly other optimizations sometimes create new refs using ond
    2516                 :            :      refs as the model.  */
    2517                 : 4098880000 :   DF_REF_FLAGS_CLEAR (this_ref, DF_HARD_REG_LIVE);
    2518                 :            : 
    2519                 :            :   /* See if this ref needs to have DF_HARD_REG_LIVE bit set.  */
    2520                 : 4098880000 :   if (regno < FIRST_PSEUDO_REGISTER
    2521                 : 3875810000 :       && !DF_REF_IS_ARTIFICIAL (this_ref)
    2522                 : 3576340000 :       && !DEBUG_INSN_P (DF_REF_INSN (this_ref)))
    2523                 :            :     {
    2524                 : 3548000000 :       if (DF_REF_REG_DEF_P (this_ref))
    2525                 :            :         {
    2526                 : 3115370000 :           if (!DF_REF_FLAGS_IS_SET (this_ref, DF_REF_MAY_CLOBBER))
    2527                 :  260740000 :             DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
    2528                 :            :         }
    2529                 :  432634000 :       else if (!(TEST_HARD_REG_BIT (elim_reg_set, regno)
    2530                 :   41871200 :                  && (regno == FRAME_POINTER_REGNUM
    2531                 :   41871200 :                      || regno == ARG_POINTER_REGNUM)))
    2532                 :  390763000 :         DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
    2533                 :            :     }
    2534                 :            : 
    2535                 : 4098880000 :   if (collection_rec)
    2536                 :            :     {
    2537                 : 4096500000 :       if (DF_REF_REG_DEF_P (this_ref))
    2538                 : 3314330000 :         collection_rec->def_vec.safe_push (this_ref);
    2539                 :  782173000 :       else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
    2540                 :   24636700 :         collection_rec->eq_use_vec.safe_push (this_ref);
    2541                 :            :       else
    2542                 :  757537000 :         collection_rec->use_vec.safe_push (this_ref);
    2543                 :            :     }
    2544                 :            :   else
    2545                 :    2381610 :     df_install_ref_incremental (this_ref);
    2546                 :            : 
    2547                 : 4098880000 :   return this_ref;
    2548                 :            : }
    2549                 :            : 
    2550                 :            : 
    2551                 :            : /* Create new references of type DF_REF_TYPE for each part of register REG
    2552                 :            :    at address LOC within INSN of BB.  */
    2553                 :            : 
    2554                 :            : 
    2555                 :            : static void
    2556                 : 4095040000 : df_ref_record (enum df_ref_class cl,
    2557                 :            :                class df_collection_rec *collection_rec,
    2558                 :            :                rtx reg, rtx *loc,
    2559                 :            :                basic_block bb, struct df_insn_info *insn_info,
    2560                 :            :                enum df_ref_type ref_type,
    2561                 :            :                int ref_flags)
    2562                 :            : {
    2563                 : 4095040000 :   unsigned int regno;
    2564                 :            : 
    2565                 : 4095040000 :   gcc_checking_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
    2566                 :            : 
    2567                 : 4095040000 :   regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
    2568                 : 4095040000 :   if (regno < FIRST_PSEUDO_REGISTER)
    2569                 :            :     {
    2570                 : 3871960000 :       struct df_mw_hardreg *hardreg = NULL;
    2571                 : 3871960000 :       struct df_scan_problem_data *problem_data
    2572                 : 3871960000 :         = (struct df_scan_problem_data *) df_scan->problem_data;
    2573                 : 3871960000 :       unsigned int i;
    2574                 : 3871960000 :       unsigned int endregno;
    2575                 : 3871960000 :       df_ref ref;
    2576                 :            : 
    2577                 : 3871960000 :       if (GET_CODE (reg) == SUBREG)
    2578                 :            :         {
    2579                 :     169882 :           regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
    2580                 :      84941 :                                         SUBREG_BYTE (reg), GET_MODE (reg));
    2581                 :      84941 :           endregno = regno + subreg_nregs (reg);
    2582                 :            :         }
    2583                 :            :       else
    2584                 : 3871870000 :         endregno = END_REGNO (reg);
    2585                 :            : 
    2586                 :            :       /*  If this is a multiword hardreg, we create some extra
    2587                 :            :           datastructures that will enable us to easily build REG_DEAD
    2588                 :            :           and REG_UNUSED notes.  */
    2589                 : 3871960000 :       if (collection_rec
    2590                 : 3871710000 :           && (endregno != regno + 1) && insn_info)
    2591                 :            :         {
    2592                 :            :           /* Sets to a subreg of a multiword register are partial.
    2593                 :            :              Sets to a non-subreg of a multiword register are not.  */
    2594                 :    3843890 :           if (GET_CODE (reg) == SUBREG)
    2595                 :         18 :             ref_flags |= DF_REF_PARTIAL;
    2596                 :    3843890 :           ref_flags |= DF_REF_MW_HARDREG;
    2597                 :            : 
    2598                 :    3843890 :           hardreg = problem_data->mw_reg_pool->allocate ();
    2599                 :    3843890 :           hardreg->type = ref_type;
    2600                 :    3843890 :           hardreg->flags = ref_flags;
    2601                 :    3843890 :           hardreg->mw_reg = reg;
    2602                 :    3843890 :           hardreg->start_regno = regno;
    2603                 :    3843890 :           hardreg->end_regno = endregno - 1;
    2604                 :    3843890 :           hardreg->mw_order = df->ref_order++;
    2605                 :    3843890 :           collection_rec->mw_vec.safe_push (hardreg);
    2606                 :            :         }
    2607                 :            : 
    2608                 : 7747770000 :       for (i = regno; i < endregno; i++)
    2609                 :            :         {
    2610                 : 3875810000 :           ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc,
    2611                 :            :                                          bb, insn_info, ref_type, ref_flags);
    2612                 :            : 
    2613                 : 3875810000 :           gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
    2614                 :            :         }
    2615                 :            :     }
    2616                 :            :   else
    2617                 :            :     {
    2618                 :  223077000 :       df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info,
    2619                 :            :                                ref_type, ref_flags);
    2620                 :            :     }
    2621                 : 4095040000 : }
    2622                 :            : 
    2623                 :            : 
    2624                 :            : /* Process all the registers defined in the rtx pointed by LOC.
    2625                 :            :    Autoincrement/decrement definitions will be picked up by df_uses_record.
    2626                 :            :    Any change here has to be matched in df_find_hard_reg_defs_1.  */
    2627                 :            : 
    2628                 :            : static void
    2629                 :  443245000 : df_def_record_1 (class df_collection_rec *collection_rec,
    2630                 :            :                  rtx *loc, basic_block bb, struct df_insn_info *insn_info,
    2631                 :            :                  int flags)
    2632                 :            : {
    2633                 :  443245000 :   rtx dst = *loc;
    2634                 :            : 
    2635                 :            :   /* It is legal to have a set destination be a parallel. */
    2636                 :  443245000 :   if (GET_CODE (dst) == PARALLEL)
    2637                 :            :     {
    2638                 :      91662 :       int i;
    2639                 :     249332 :       for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
    2640                 :            :         {
    2641                 :     157670 :           rtx temp = XVECEXP (dst, 0, i);
    2642                 :     157670 :           gcc_assert (GET_CODE (temp) == EXPR_LIST);
    2643                 :     157670 :           df_def_record_1 (collection_rec, &XEXP (temp, 0),
    2644                 :            :                            bb, insn_info, flags);
    2645                 :            :         }
    2646                 :            :       return;
    2647                 :            :     }
    2648                 :            : 
    2649                 :  443154000 :   if (GET_CODE (dst) == STRICT_LOW_PART)
    2650                 :            :     {
    2651                 :      80557 :       flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_STRICT_LOW_PART;
    2652                 :            : 
    2653                 :      80557 :       loc = &XEXP (dst, 0);
    2654                 :      80557 :       dst = *loc;
    2655                 :            :     }
    2656                 :            : 
    2657                 :  443154000 :   if (GET_CODE (dst) == ZERO_EXTRACT)
    2658                 :            :     {
    2659                 :      38573 :       flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT;
    2660                 :            : 
    2661                 :      38573 :       loc = &XEXP (dst, 0);
    2662                 :      38573 :       dst = *loc;
    2663                 :            :     }
    2664                 :            : 
    2665                 :            :   /* At this point if we do not have a reg or a subreg, just return.  */
    2666                 :  443154000 :   if (REG_P (dst))
    2667                 :            :     {
    2668                 :  317014000 :       df_ref_record (DF_REF_REGULAR, collection_rec,
    2669                 :            :                      dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
    2670                 :            : 
    2671                 :            :       /* We want to keep sp alive everywhere - by making all
    2672                 :            :          writes to sp also use of sp. */
    2673                 :  317014000 :       if (REGNO (dst) == STACK_POINTER_REGNUM)
    2674                 :   12997800 :         df_ref_record (DF_REF_BASE, collection_rec,
    2675                 :            :                        dst, NULL, bb, insn_info, DF_REF_REG_USE, flags);
    2676                 :            :     }
    2677                 :  126140000 :   else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
    2678                 :            :     {
    2679                 :    1355540 :       if (read_modify_subreg_p (dst))
    2680                 :     896932 :         flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL;
    2681                 :            : 
    2682                 :    1355540 :       flags |= DF_REF_SUBREG;
    2683                 :            : 
    2684                 :    1355540 :       df_ref_record (DF_REF_REGULAR, collection_rec,
    2685                 :            :                      dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
    2686                 :            :     }
    2687                 :            : }
    2688                 :            : 
    2689                 :            : 
    2690                 :            : /* Process all the registers defined in the pattern rtx, X.  Any change
    2691                 :            :    here has to be matched in df_find_hard_reg_defs.  */
    2692                 :            : 
    2693                 :            : static void
    2694                 :  746787000 : df_defs_record (class df_collection_rec *collection_rec,
    2695                 :            :                 rtx x, basic_block bb, struct df_insn_info *insn_info,
    2696                 :            :                 int flags)
    2697                 :            : {
    2698                 :  746787000 :   RTX_CODE code = GET_CODE (x);
    2699                 :  746787000 :   int i;
    2700                 :            : 
    2701                 :  746787000 :   switch (code)
    2702                 :            :     {
    2703                 :  389052000 :     case SET:
    2704                 :  389052000 :       df_def_record_1 (collection_rec, &SET_DEST (x), bb, insn_info, flags);
    2705                 :  389052000 :       break;
    2706                 :            : 
    2707                 :   54036000 :     case CLOBBER:
    2708                 :   54036000 :       flags |= DF_REF_MUST_CLOBBER;
    2709                 :   54036000 :       df_def_record_1 (collection_rec, &XEXP (x, 0), bb, insn_info, flags);
    2710                 :   54036000 :       break;
    2711                 :            : 
    2712                 :          0 :     case COND_EXEC:
    2713                 :          0 :       df_defs_record (collection_rec, COND_EXEC_CODE (x),
    2714                 :            :                       bb, insn_info, DF_REF_CONDITIONAL);
    2715                 :          0 :       break;
    2716                 :            : 
    2717                 :            :     case PARALLEL:
    2718                 :  160955000 :       for (i = 0; i < XVECLEN (x, 0); i++)
    2719                 :  109392000 :         df_defs_record (collection_rec, XVECEXP (x, 0, i),
    2720                 :            :                         bb, insn_info, flags);
    2721                 :            :       break;
    2722                 :            :     default:
    2723                 :            :       /* No DEFs to record in other cases */
    2724                 :            :       break;
    2725                 :            :     }
    2726                 :  746787000 : }
    2727                 :            : 
    2728                 :            : /* Set bits in *DEFS for hard registers found in the rtx DST, which is the
    2729                 :            :    destination of a set or clobber.  This has to match the logic in
    2730                 :            :    df_defs_record_1.  */
    2731                 :            : 
    2732                 :            : static void
    2733                 :   17819600 : df_find_hard_reg_defs_1 (rtx dst, HARD_REG_SET *defs)
    2734                 :            : {
    2735                 :            :   /* It is legal to have a set destination be a parallel. */
    2736                 :   17819600 :   if (GET_CODE (dst) == PARALLEL)
    2737                 :            :     {
    2738                 :      91662 :       int i;
    2739                 :     249332 :       for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
    2740                 :            :         {
    2741                 :     157670 :           rtx temp = XVECEXP (dst, 0, i);
    2742                 :     157670 :           gcc_assert (GET_CODE (temp) == EXPR_LIST);
    2743                 :     157670 :           df_find_hard_reg_defs_1 (XEXP (temp, 0), defs);
    2744                 :            :         }
    2745                 :            :       return;
    2746                 :            :     }
    2747                 :            : 
    2748                 :   17728000 :   if (GET_CODE (dst) == STRICT_LOW_PART)
    2749                 :          0 :       dst = XEXP (dst, 0);
    2750                 :            : 
    2751                 :   17728000 :   if (GET_CODE (dst) == ZERO_EXTRACT)
    2752                 :          0 :       dst = XEXP (dst, 0);
    2753                 :            : 
    2754                 :            :   /* At this point if we do not have a reg or a subreg, just return.  */
    2755                 :   17728000 :   if (REG_P (dst) && HARD_REGISTER_P (dst))
    2756                 :   17728000 :     SET_HARD_REG_BIT (*defs, REGNO (dst));
    2757                 :          0 :   else if (GET_CODE (dst) == SUBREG
    2758                 :          0 :            && REG_P (SUBREG_REG (dst)) && HARD_REGISTER_P (dst))
    2759                 :          0 :     SET_HARD_REG_BIT (*defs, REGNO (SUBREG_REG (dst)));
    2760                 :            : }
    2761                 :            : 
    2762                 :            : /* Set bits in *DEFS for hard registers defined in the pattern X.  This
    2763                 :            :    has to match the logic in df_defs_record.  */
    2764                 :            : 
    2765                 :            : static void
    2766                 :   46511300 : df_find_hard_reg_defs (rtx x, HARD_REG_SET *defs)
    2767                 :            : {
    2768                 :   46511300 :   RTX_CODE code = GET_CODE (x);
    2769                 :   46511300 :   int i;
    2770                 :            : 
    2771                 :   46511300 :   switch (code)
    2772                 :            :     {
    2773                 :   17661900 :     case SET:
    2774                 :   17661900 :       df_find_hard_reg_defs_1 (SET_DEST (x), defs);
    2775                 :   17661900 :       break;
    2776                 :            : 
    2777                 :          0 :     case CLOBBER:
    2778                 :          0 :       df_find_hard_reg_defs_1 (XEXP (x, 0), defs);
    2779                 :          0 :       break;
    2780                 :            : 
    2781                 :          0 :     case COND_EXEC:
    2782                 :          0 :       df_find_hard_reg_defs (COND_EXEC_CODE (x), defs);
    2783                 :          0 :       break;
    2784                 :            : 
    2785                 :            :     case PARALLEL:
    2786                 :    4421770 :       for (i = 0; i < XVECLEN (x, 0); i++)
    2787                 :    2947840 :         df_find_hard_reg_defs (XVECEXP (x, 0, i), defs);
    2788                 :            :       break;
    2789                 :            :     default:
    2790                 :            :       /* No DEFs to record in other cases */
    2791                 :            :       break;
    2792                 :            :     }
    2793                 :   46511300 : }
    2794                 :            : 
    2795                 :            : 
    2796                 :            : /* Process all the registers used in the rtx at address LOC.  */
    2797                 :            : 
    2798                 :            : static void
    2799                 : 1669770000 : df_uses_record (class df_collection_rec *collection_rec,
    2800                 :            :                 rtx *loc, enum df_ref_type ref_type,
    2801                 :            :                 basic_block bb, struct df_insn_info *insn_info,
    2802                 :            :                 int flags)
    2803                 :            : {
    2804                 : 2454530000 :   RTX_CODE code;
    2805                 : 2454530000 :   rtx x;
    2806                 :            : 
    2807                 : 2454530000 :  retry:
    2808                 : 2454530000 :   x = *loc;
    2809                 : 2454530000 :   if (!x)
    2810                 :            :     return;
    2811                 : 2454530000 :   code = GET_CODE (x);
    2812                 : 2454530000 :   switch (code)
    2813                 :            :     {
    2814                 :            :     case LABEL_REF:
    2815                 :            :     case SYMBOL_REF:
    2816                 :            :     case CONST:
    2817                 :            :     CASE_CONST_ANY:
    2818                 :            :     case PC:
    2819                 :            :     case CC0:
    2820                 :            :     case ADDR_VEC:
    2821                 :            :     case ADDR_DIFF_VEC:
    2822                 :            :       return;
    2823                 :            : 
    2824                 :  134007000 :     case CLOBBER:
    2825                 :            :       /* If we are clobbering a MEM, mark any registers inside the address
    2826                 :            :          as being used.  */
    2827                 :  134007000 :       if (MEM_P (XEXP (x, 0)))
    2828                 :    2274550 :         df_uses_record (collection_rec,
    2829                 :            :                         &XEXP (XEXP (x, 0), 0),
    2830                 :            :                         DF_REF_REG_MEM_STORE,
    2831                 :            :                         bb, insn_info,
    2832                 :            :                         flags);
    2833                 :            : 
    2834                 :            :       /* If we're clobbering a REG then we have a def so ignore.  */
    2835                 :            :       return;
    2836                 :            : 
    2837                 :  136632000 :     case MEM:
    2838                 :  136632000 :       df_uses_record (collection_rec,
    2839                 :            :                       &XEXP (x, 0), DF_REF_REG_MEM_LOAD,
    2840                 :            :                       bb, insn_info, flags & DF_REF_IN_NOTE);
    2841                 :  136632000 :       return;
    2842                 :            : 
    2843                 :    5496540 :     case SUBREG:
    2844                 :            :       /* While we're here, optimize this case.  */
    2845                 :    5496540 :       flags |= DF_REF_PARTIAL;
    2846                 :            :       /* In case the SUBREG is not of a REG, do not optimize.  */
    2847                 :    5496540 :       if (!REG_P (SUBREG_REG (x)))
    2848                 :            :         {
    2849                 :     298361 :           loc = &SUBREG_REG (x);
    2850                 :     298361 :           df_uses_record (collection_rec, loc, ref_type, bb, insn_info, flags);
    2851                 :     298361 :           return;
    2852                 :            :         }
    2853                 :            :       /* Fall through */
    2854                 :            : 
    2855                 :  545074000 :     case REG:
    2856                 :  545074000 :       df_ref_record (DF_REF_REGULAR, collection_rec,
    2857                 :            :                      x, loc, bb, insn_info,
    2858                 :            :                      ref_type, flags);
    2859                 :  545074000 :       return;
    2860                 :            : 
    2861                 :     185824 :     case SIGN_EXTRACT:
    2862                 :     185824 :     case ZERO_EXTRACT:
    2863                 :     185824 :       {
    2864                 :     185824 :         df_uses_record (collection_rec,
    2865                 :            :                         &XEXP (x, 1), ref_type, bb, insn_info, flags);
    2866                 :     185824 :         df_uses_record (collection_rec,
    2867                 :            :                         &XEXP (x, 2), ref_type, bb, insn_info, flags);
    2868                 :            : 
    2869                 :            :         /* If the parameters to the zero or sign extract are
    2870                 :            :            constants, strip them off and recurse, otherwise there is
    2871                 :            :            no information that we can gain from this operation.  */
    2872                 :     185824 :         if (code == ZERO_EXTRACT)
    2873                 :     181147 :           flags |= DF_REF_ZERO_EXTRACT;
    2874                 :            :         else
    2875                 :       4677 :           flags |= DF_REF_SIGN_EXTRACT;
    2876                 :            : 
    2877                 :     185824 :         df_uses_record (collection_rec,
    2878                 :            :                         &XEXP (x, 0), ref_type, bb, insn_info, flags);
    2879                 :     185824 :         return;
    2880                 :            :       }
    2881                 :  390728000 :       break;
    2882                 :            : 
    2883                 :  390728000 :     case SET:
    2884                 :  390728000 :       {
    2885                 :  390728000 :         rtx dst = SET_DEST (x);
    2886                 :  390728000 :         gcc_assert (!(flags & DF_REF_IN_NOTE));
    2887                 :  390728000 :         df_uses_record (collection_rec,
    2888                 :            :                         &SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags);
    2889                 :            : 
    2890                 :  390728000 :         switch (GET_CODE (dst))
    2891                 :            :           {
    2892                 :    1348580 :             case SUBREG:
    2893                 :    1348580 :               if (read_modify_subreg_p (dst))
    2894                 :            :                 {
    2895                 :     903277 :                   df_uses_record (collection_rec, &SUBREG_REG (dst),
    2896                 :            :                                   DF_REF_REG_USE, bb, insn_info,
    2897                 :            :                                   flags | DF_REF_READ_WRITE | DF_REF_SUBREG);
    2898                 :     903277 :                   break;
    2899                 :            :                 }
    2900                 :            :               /* Fall through.  */
    2901                 :            :             case REG:
    2902                 :            :             case PARALLEL:
    2903                 :            :             case SCRATCH:
    2904                 :            :             case PC:
    2905                 :            :             case CC0:
    2906                 :            :                 break;
    2907                 :   74462600 :             case MEM:
    2908                 :   74462600 :               df_uses_record (collection_rec, &XEXP (dst, 0),
    2909                 :            :                               DF_REF_REG_MEM_STORE, bb, insn_info, flags);
    2910                 :   74462600 :               break;
    2911                 :      80557 :             case STRICT_LOW_PART:
    2912                 :      80557 :               {
    2913                 :      80557 :                 rtx *temp = &XEXP (dst, 0);
    2914                 :            :                 /* A strict_low_part uses the whole REG and not just the
    2915                 :            :                  SUBREG.  */
    2916                 :      80557 :                 dst = XEXP (dst, 0);
    2917                 :      14093 :                 df_uses_record (collection_rec,
    2918                 :      80557 :                                 (GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
    2919                 :            :                                 DF_REF_REG_USE, bb, insn_info,
    2920                 :            :                                 DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART);
    2921                 :            :               }
    2922                 :      80557 :               break;
    2923                 :      38620 :             case ZERO_EXTRACT:
    2924                 :      38620 :               {
    2925                 :      38620 :                 df_uses_record (collection_rec, &XEXP (dst, 1),
    2926                 :            :                                 DF_REF_REG_USE, bb, insn_info, flags);
    2927                 :      38620 :                 df_uses_record (collection_rec, &XEXP (dst, 2),
    2928                 :            :                                 DF_REF_REG_USE, bb, insn_info, flags);
    2929                 :      38620 :                 if (GET_CODE (XEXP (dst,0)) == MEM)
    2930                 :       2269 :                   df_uses_record (collection_rec, &XEXP (dst, 0),
    2931                 :            :                                   DF_REF_REG_USE, bb, insn_info,
    2932                 :            :                                   flags);
    2933                 :            :                 else
    2934                 :      36351 :                   df_uses_record (collection_rec, &XEXP (dst, 0),
    2935                 :            :                                   DF_REF_REG_USE, bb, insn_info,
    2936                 :            :                                   DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT);
    2937                 :            :               }
    2938                 :            :               break;
    2939                 :            : 
    2940                 :          0 :             default:
    2941                 :          0 :               gcc_unreachable ();
    2942                 :            :           }
    2943                 :            :         return;
    2944                 :            :       }
    2945                 :            : 
    2946                 :            :     case RETURN:
    2947                 :            :     case SIMPLE_RETURN:
    2948                 :            :       break;
    2949                 :            : 
    2950                 :    4130770 :     case ASM_OPERANDS:
    2951                 :    4130770 :     case UNSPEC_VOLATILE:
    2952                 :    4130770 :     case TRAP_IF:
    2953                 :    4130770 :     case ASM_INPUT:
    2954                 :    4130770 :       {
    2955                 :            :         /* Traditional and volatile asm instructions must be
    2956                 :            :            considered to use and clobber all hard registers, all
    2957                 :            :            pseudo-registers and all of memory.  So must TRAP_IF and
    2958                 :            :            UNSPEC_VOLATILE operations.
    2959                 :            : 
    2960                 :            :            Consider for instance a volatile asm that changes the fpu
    2961                 :            :            rounding mode.  An insn should not be moved across this
    2962                 :            :            even if it only uses pseudo-regs because it might give an
    2963                 :            :            incorrectly rounded result.
    2964                 :            : 
    2965                 :            :            However, flow.c's liveness computation did *not* do this,
    2966                 :            :            giving the reasoning as " ?!? Unfortunately, marking all
    2967                 :            :            hard registers as live causes massive problems for the
    2968                 :            :            register allocator and marking all pseudos as live creates
    2969                 :            :            mountains of uninitialized variable warnings."
    2970                 :            : 
    2971                 :            :            In order to maintain the status quo with regard to liveness
    2972                 :            :            and uses, we do what flow.c did and just mark any regs we
    2973                 :            :            can find in ASM_OPERANDS as used.  In global asm insns are
    2974                 :            :            scanned and regs_asm_clobbered is filled out.
    2975                 :            : 
    2976                 :            :            For all ASM_OPERANDS, we must traverse the vector of input
    2977                 :            :            operands.  We cannot just fall through here since then we
    2978                 :            :            would be confused by the ASM_INPUT rtx inside ASM_OPERANDS,
    2979                 :            :            which do not indicate traditional asms unlike their normal
    2980                 :            :            usage.  */
    2981                 :    4130770 :         if (code == ASM_OPERANDS)
    2982                 :            :           {
    2983                 :            :             int j;
    2984                 :            : 
    2985                 :    1783090 :             for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
    2986                 :     830890 :               df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
    2987                 :            :                               DF_REF_REG_USE, bb, insn_info, flags);
    2988                 :            :             return;
    2989                 :            :           }
    2990                 :            :         break;
    2991                 :            :       }
    2992                 :            : 
    2993                 :  168336000 :     case VAR_LOCATION:
    2994                 :  168336000 :       df_uses_record (collection_rec,
    2995                 :            :                       &PAT_VAR_LOCATION_LOC (x),
    2996                 :            :                       DF_REF_REG_USE, bb, insn_info, flags);
    2997                 :  168336000 :       return;
    2998                 :            : 
    2999                 :   20924600 :     case PRE_DEC:
    3000                 :   20924600 :     case POST_DEC:
    3001                 :   20924600 :     case PRE_INC:
    3002                 :   20924600 :     case POST_INC:
    3003                 :   20924600 :     case PRE_MODIFY:
    3004                 :   20924600 :     case POST_MODIFY:
    3005                 :   20924600 :       gcc_assert (!DEBUG_INSN_P (insn_info->insn));
    3006                 :            :       /* Catch the def of the register being modified.  */
    3007                 :   20924600 :       df_ref_record (DF_REF_REGULAR, collection_rec, XEXP (x, 0), &XEXP (x, 0),
    3008                 :            :                      bb, insn_info,
    3009                 :            :                      DF_REF_REG_DEF,
    3010                 :            :                      flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY);
    3011                 :            : 
    3012                 :            :       /* ... Fall through to handle uses ...  */
    3013                 :            : 
    3014                 :            :     default:
    3015                 :            :       break;
    3016                 :            :     }
    3017                 :            : 
    3018                 :            :   /* Recursively scan the operands of this expression.  */
    3019                 :  550372000 :   {
    3020                 :  550372000 :     const char *fmt = GET_RTX_FORMAT (code);
    3021                 :  550372000 :     int i;
    3022                 :            : 
    3023                 : 1061500000 :     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3024                 :            :       {
    3025                 :  912674000 :         if (fmt[i] == 'e')
    3026                 :            :           {
    3027                 :            :             /* Tail recursive case: save a function call level.  */
    3028                 :  809538000 :             if (i == 0)
    3029                 :            :               {
    3030                 :  401547000 :                 loc = &XEXP (x, 0);
    3031                 :  401547000 :                 goto retry;
    3032                 :            :               }
    3033                 :  407991000 :             df_uses_record (collection_rec, &XEXP (x, i), ref_type,
    3034                 :            :                             bb, insn_info, flags);
    3035                 :            :           }
    3036                 :  103136000 :         else if (fmt[i] == 'E')
    3037                 :            :           {
    3038                 :            :             int j;
    3039                 :  188265000 :             for (j = 0; j < XVECLEN (x, i); j++)
    3040                 :  126836000 :               df_uses_record (collection_rec,
    3041                 :            :                               &XVECEXP (x, i, j), ref_type,
    3042                 :            :                               bb, insn_info, flags);
    3043                 :            :           }
    3044                 :            :       }
    3045                 :            :   }
    3046                 :            : 
    3047                 :            :   return;
    3048                 :            : }
    3049                 :            : 
    3050                 :            : 
    3051                 :            : /* For all DF_REF_CONDITIONAL defs, add a corresponding uses.  */
    3052                 :            : 
    3053                 :            : static void
    3054                 :          0 : df_get_conditional_uses (class df_collection_rec *collection_rec)
    3055                 :            : {
    3056                 :          0 :   unsigned int ix;
    3057                 :          0 :   df_ref ref;
    3058                 :            : 
    3059                 :          0 :   FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
    3060                 :            :     {
    3061                 :          0 :       if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
    3062                 :            :         {
    3063                 :          0 :           df_ref use;
    3064                 :            : 
    3065                 :          0 :           use = df_ref_create_structure (DF_REF_CLASS (ref), collection_rec, DF_REF_REG (ref),
    3066                 :          0 :                                          DF_REF_LOC (ref), DF_REF_BB (ref),
    3067                 :            :                                          DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
    3068                 :            :                                          DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL);
    3069                 :          0 :           DF_REF_REGNO (use) = DF_REF_REGNO (ref);
    3070                 :            :         }
    3071                 :            :     }
    3072                 :          0 : }
    3073                 :            : 
    3074                 :            : 
    3075                 :            : /* Get call's extra defs and uses (track caller-saved registers). */
    3076                 :            : 
    3077                 :            : static void
    3078                 :   43563500 : df_get_call_refs (class df_collection_rec *collection_rec,
    3079                 :            :                   basic_block bb,
    3080                 :            :                   struct df_insn_info *insn_info,
    3081                 :            :                   int flags)
    3082                 :            : {
    3083                 :   43563500 :   rtx note;
    3084                 :   43563500 :   bool is_sibling_call;
    3085                 :   43563500 :   unsigned int i;
    3086                 :   43563500 :   HARD_REG_SET defs_generated;
    3087                 :            : 
    3088                 :   43563500 :   CLEAR_HARD_REG_SET (defs_generated);
    3089                 :   43563500 :   df_find_hard_reg_defs (PATTERN (insn_info->insn), &defs_generated);
    3090                 :   43563500 :   is_sibling_call = SIBLING_CALL_P (insn_info->insn);
    3091                 :   43563500 :   function_abi callee_abi = insn_callee_abi (insn_info->insn);
    3092                 :            : 
    3093                 : 3354390000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3094                 :            :     {
    3095                 : 3310820000 :       if (i == STACK_POINTER_REGNUM)
    3096                 :            :         /* The stack ptr is used (honorarily) by a CALL insn.  */
    3097                 :   43563500 :         df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
    3098                 :            :                        NULL, bb, insn_info, DF_REF_REG_USE,
    3099                 :            :                        DF_REF_CALL_STACK_USAGE | flags);
    3100                 : 3267260000 :       else if (global_regs[i])
    3101                 :            :         {
    3102                 :            :           /* Calls to const functions cannot access any global registers and
    3103                 :            :              calls to pure functions cannot set them.  All other calls may
    3104                 :            :              reference any of the global registers, so they are recorded as
    3105                 :            :              used. */
    3106                 :        391 :           if (!RTL_CONST_CALL_P (insn_info->insn))
    3107                 :            :             {
    3108                 :        391 :               df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
    3109                 :            :                              NULL, bb, insn_info, DF_REF_REG_USE, flags);
    3110                 :        391 :               if (!RTL_PURE_CALL_P (insn_info->insn))
    3111                 :        278 :                 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
    3112                 :            :                                NULL, bb, insn_info, DF_REF_REG_DEF, flags);
    3113                 :            :             }
    3114                 :            :         }
    3115                 : 3267260000 :       else if (callee_abi.clobbers_full_reg_p (i)
    3116                 :            :                /* no clobbers for regs that are the result of the call */
    3117                 : 2870920000 :                && !TEST_HARD_REG_BIT (defs_generated, i)
    3118                 : 6121890000 :                && (!is_sibling_call
    3119                 :   58928100 :                    || !bitmap_bit_p (df->exit_block_uses, i)
    3120                 :       8899 :                    || refers_to_regno_p (i, crtl->return_rtx)))
    3121                 : 2854630000 :           df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
    3122                 :            :                          NULL, bb, insn_info, DF_REF_REG_DEF,
    3123                 :            :                          DF_REF_MAY_CLOBBER | flags);
    3124                 :            :     }
    3125                 :            : 
    3126                 :            :   /* Record the registers used to pass arguments, and explicitly
    3127                 :            :      noted as clobbered.  */
    3128                 :  117199000 :   for (note = CALL_INSN_FUNCTION_USAGE (insn_info->insn); note;
    3129                 :   73635500 :        note = XEXP (note, 1))
    3130                 :            :     {
    3131                 :   73635500 :       if (GET_CODE (XEXP (note, 0)) == USE)
    3132                 :   71351500 :         df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
    3133                 :            :                         DF_REF_REG_USE, bb, insn_info, flags);
    3134                 :    2283960 :       else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
    3135                 :            :         {
    3136                 :    1686800 :           if (REG_P (XEXP (XEXP (note, 0), 0)))
    3137                 :            :             {
    3138                 :    1686800 :               unsigned int regno = REGNO (XEXP (XEXP (note, 0), 0));
    3139                 :    1686800 :               if (!TEST_HARD_REG_BIT (defs_generated, regno))
    3140                 :    1686470 :                 df_defs_record (collection_rec, XEXP (note, 0), bb,
    3141                 :            :                                 insn_info, flags);
    3142                 :            :             }
    3143                 :            :           else
    3144                 :          0 :             df_uses_record (collection_rec, &XEXP (note, 0),
    3145                 :            :                             DF_REF_REG_USE, bb, insn_info, flags);
    3146                 :            :         }
    3147                 :            :     }
    3148                 :            : 
    3149                 :   43563500 :   return;
    3150                 :            : }
    3151                 :            : 
    3152                 :            : /* Collect all refs in the INSN. This function is free of any
    3153                 :            :    side-effect - it will create and return a lists of df_ref's in the
    3154                 :            :    COLLECTION_REC without putting those refs into existing ref chains
    3155                 :            :    and reg chains. */
    3156                 :            : 
    3157                 :            : static void
    3158                 :  635709000 : df_insn_refs_collect (class df_collection_rec *collection_rec,
    3159                 :            :                       basic_block bb, struct df_insn_info *insn_info)
    3160                 :            : {
    3161                 :  635709000 :   rtx note;
    3162                 :  635709000 :   bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
    3163                 :            : 
    3164                 :            :   /* Clear out the collection record.  */
    3165                 :  635709000 :   collection_rec->def_vec.truncate (0);
    3166                 :  635709000 :   collection_rec->use_vec.truncate (0);
    3167                 :  635709000 :   collection_rec->eq_use_vec.truncate (0);
    3168                 :  635709000 :   collection_rec->mw_vec.truncate (0);
    3169                 :            : 
    3170                 :            :   /* Process REG_EQUIV/REG_EQUAL notes.  */
    3171                 :  895164000 :   for (note = REG_NOTES (insn_info->insn); note;
    3172                 :  259455000 :        note = XEXP (note, 1))
    3173                 :            :     {
    3174                 :  259455000 :       switch (REG_NOTE_KIND (note))
    3175                 :            :         {
    3176                 :   22030400 :         case REG_EQUIV:
    3177                 :   22030400 :         case REG_EQUAL:
    3178                 :   22030400 :           df_uses_record (collection_rec,
    3179                 :            :                           &XEXP (note, 0), DF_REF_REG_USE,
    3180                 :            :                           bb, insn_info, DF_REF_IN_NOTE);
    3181                 :   22030400 :           break;
    3182                 :       5676 :         case REG_NON_LOCAL_GOTO:
    3183                 :            :           /* The frame ptr is used by a non-local goto.  */
    3184                 :       5676 :           df_ref_record (DF_REF_BASE, collection_rec,
    3185                 :       5676 :                          regno_reg_rtx[FRAME_POINTER_REGNUM],
    3186                 :            :                          NULL, bb, insn_info,
    3187                 :            :                          DF_REF_REG_USE, 0);
    3188                 :       5676 :           if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
    3189                 :       5676 :             df_ref_record (DF_REF_BASE, collection_rec,
    3190                 :       5676 :                            regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
    3191                 :            :                            NULL, bb, insn_info,
    3192                 :            :                            DF_REF_REG_USE, 0);
    3193                 :       5676 :           break;
    3194                 :            :         default:
    3195                 :            :           break;
    3196                 :            :         }
    3197                 :            :     }
    3198                 :            : 
    3199                 :  635709000 :   int flags = (is_cond_exec) ? DF_REF_CONDITIONAL : 0;
    3200                 :            :   /* For CALL_INSNs, first record DF_REF_BASE register defs, as well as
    3201                 :            :      uses from CALL_INSN_FUNCTION_USAGE. */
    3202                 :  635709000 :   if (CALL_P (insn_info->insn))
    3203                 :   43563500 :     df_get_call_refs (collection_rec, bb, insn_info, flags);
    3204                 :            : 
    3205                 :            :   /* Record other defs.  These should be mostly for DF_REF_REGULAR, so
    3206                 :            :      that a qsort on the defs is unnecessary in most cases.  */
    3207                 :  635709000 :   df_defs_record (collection_rec,
    3208                 :  635709000 :                   PATTERN (insn_info->insn), bb, insn_info, 0);
    3209                 :            : 
    3210                 :            :   /* Record the register uses.  */
    3211                 :  635709000 :   df_uses_record (collection_rec,
    3212                 :  635709000 :                   &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0);
    3213                 :            : 
    3214                 :            :   /* DF_REF_CONDITIONAL needs corresponding USES. */
    3215                 :  635709000 :   if (is_cond_exec)
    3216                 :          0 :     df_get_conditional_uses (collection_rec);
    3217                 :            : 
    3218                 :  635709000 :   df_canonize_collection_rec (collection_rec);
    3219                 :  635709000 : }
    3220                 :            : 
    3221                 :            : /* Recompute the luids for the insns in BB.  */
    3222                 :            : 
    3223                 :            : void
    3224                 :   15025900 : df_recompute_luids (basic_block bb)
    3225                 :            : {
    3226                 :   15025900 :   rtx_insn *insn;
    3227                 :   15025900 :   int luid = 0;
    3228                 :            : 
    3229                 :   15025900 :   df_grow_insn_info ();
    3230                 :            : 
    3231                 :            :   /* Scan the block an insn at a time from beginning to end.  */
    3232                 :  341160000 :   FOR_BB_INSNS (bb, insn)
    3233                 :            :     {
    3234                 :  163067000 :       struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    3235                 :            :       /* Inserting labels does not always trigger the incremental
    3236                 :            :          rescanning.  */
    3237                 :  163067000 :       if (!insn_info)
    3238                 :            :         {
    3239                 :    1537410 :           gcc_assert (!INSN_P (insn));
    3240                 :    1537410 :           insn_info = df_insn_create_insn_record (insn);
    3241                 :            :         }
    3242                 :            : 
    3243                 :  163067000 :       DF_INSN_INFO_LUID (insn_info) = luid;
    3244                 :  163067000 :       if (INSN_P (insn))
    3245                 :  133327000 :         luid++;
    3246                 :            :     }
    3247                 :   15025900 : }
    3248                 :            : 
    3249                 :            : 
    3250                 :            : /* Collect all artificial refs at the block level for BB and add them
    3251                 :            :    to COLLECTION_REC.  */
    3252                 :            : 
    3253                 :            : static void
    3254                 :   71780400 : df_bb_refs_collect (class df_collection_rec *collection_rec, basic_block bb)
    3255                 :            : {
    3256                 :   71780400 :   collection_rec->def_vec.truncate (0);
    3257                 :   71780400 :   collection_rec->use_vec.truncate (0);
    3258                 :   71780400 :   collection_rec->eq_use_vec.truncate (0);
    3259                 :   71780400 :   collection_rec->mw_vec.truncate (0);
    3260                 :            : 
    3261                 :   71780400 :   if (bb->index == ENTRY_BLOCK)
    3262                 :            :     {
    3263                 :    4044420 :       df_entry_block_defs_collect (collection_rec, df->entry_block_defs);
    3264                 :    4044420 :       return;
    3265                 :            :     }
    3266                 :   67736000 :   else if (bb->index == EXIT_BLOCK)
    3267                 :            :     {
    3268                 :    4044420 :       df_exit_block_uses_collect (collection_rec, df->exit_block_uses);
    3269                 :    4044420 :       return;
    3270                 :            :     }
    3271                 :            : 
    3272                 :   63691500 :   if (bb_has_eh_pred (bb))
    3273                 :            :     {
    3274                 :            :       unsigned int i;
    3275                 :            :       /* Mark the registers that will contain data for the handler.  */
    3276                 :    2225660 :       for (i = 0; ; ++i)
    3277                 :            :         {
    3278                 :    3338490 :           unsigned regno = EH_RETURN_DATA_REGNO (i);
    3279                 :    2225660 :           if (regno == INVALID_REGNUM)
    3280                 :            :             break;
    3281                 :    2225660 :           df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
    3282                 :            :                          bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
    3283                 :    2225660 :         }
    3284                 :            :     }
    3285                 :            : 
    3286                 :            :   /* Add the hard_frame_pointer if this block is the target of a
    3287                 :            :      non-local goto.  */
    3288                 :   63691500 :   if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
    3289                 :       8894 :     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, hard_frame_pointer_rtx, NULL,
    3290                 :            :                    bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
    3291                 :            : 
    3292                 :            :   /* Add the artificial uses.  */
    3293                 :   63691500 :   if (bb->index >= NUM_FIXED_BLOCKS)
    3294                 :            :     {
    3295                 :   63691500 :       bitmap_iterator bi;
    3296                 :   63691500 :       unsigned int regno;
    3297                 :   63691500 :       bitmap au = bb_has_eh_pred (bb)
    3298                 :   63691500 :         ? &df->eh_block_artificial_uses
    3299                 :   62578700 :         : &df->regular_block_artificial_uses;
    3300                 :            : 
    3301                 :  225610000 :       EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
    3302                 :            :         {
    3303                 :  161919000 :           df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
    3304                 :            :                          bb, NULL, DF_REF_REG_USE, 0);
    3305                 :            :         }
    3306                 :            :     }
    3307                 :            : 
    3308                 :   63691500 :   df_canonize_collection_rec (collection_rec);
    3309                 :            : }
    3310                 :            : 
    3311                 :            : 
    3312                 :            : /* Record all the refs within the basic block BB_INDEX and scan the instructions if SCAN_INSNS.  */
    3313                 :            : 
    3314                 :            : void
    3315                 :   27011700 : df_bb_refs_record (int bb_index, bool scan_insns)
    3316                 :            : {
    3317                 :   27011700 :   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
    3318                 :   27011700 :   rtx_insn *insn;
    3319                 :   27011700 :   int luid = 0;
    3320                 :            : 
    3321                 :   27011700 :   if (!df)
    3322                 :    4030650 :     return;
    3323                 :            : 
    3324                 :   45962200 :   df_collection_rec collection_rec;
    3325                 :   22981100 :   df_grow_bb_info (df_scan);
    3326                 :   22981100 :   if (scan_insns)
    3327                 :            :     /* Scan the block an insn at a time from beginning to end.  */
    3328                 :  229000000 :     FOR_BB_INSNS (bb, insn)
    3329                 :            :       {
    3330                 :  209837000 :         struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    3331                 :  209837000 :         gcc_assert (!insn_info);
    3332                 :            : 
    3333                 :  209837000 :         insn_info = df_insn_create_insn_record (insn);
    3334                 :  209837000 :         if (INSN_P (insn))
    3335                 :            :           {
    3336                 :            :             /* Record refs within INSN.  */
    3337                 :  175235000 :             DF_INSN_INFO_LUID (insn_info) = luid++;
    3338                 :  175235000 :             df_insn_refs_collect (&collection_rec, bb, DF_INSN_INFO_GET (insn));
    3339                 :  175235000 :             df_refs_add_to_chains (&collection_rec, bb, insn, copy_all);
    3340                 :            :           }
    3341                 :  209837000 :         DF_INSN_INFO_LUID (insn_info) = luid;
    3342                 :            :       }
    3343                 :            : 
    3344                 :            :   /* Other block level artificial refs */
    3345                 :   22981100 :   df_bb_refs_collect (&collection_rec, bb);
    3346                 :   22981100 :   df_refs_add_to_chains (&collection_rec, bb, NULL, copy_all);
    3347                 :            : 
    3348                 :            :   /* Now that the block has been processed, set the block as dirty so
    3349                 :            :      LR and LIVE will get it processed.  */
    3350                 :   22981100 :   df_set_bb_dirty (bb);
    3351                 :            : }
    3352                 :            : 
    3353                 :            : 
    3354                 :            : /* Get the artificial use set for a regular (i.e. non-exit/non-entry)
    3355                 :            :    block. */
    3356                 :            : 
    3357                 :            : static void
    3358                 :    6004870 : df_get_regular_block_artificial_uses (bitmap regular_block_artificial_uses)
    3359                 :            : {
    3360                 :            : #ifdef EH_USES
    3361                 :            :   unsigned int i;
    3362                 :            : #endif
    3363                 :            : 
    3364                 :    6004870 :   bitmap_clear (regular_block_artificial_uses);
    3365                 :            : 
    3366                 :    6004870 :   if (reload_completed)
    3367                 :            :     {
    3368                 :    3328890 :       if (frame_pointer_needed)
    3369                 :     721904 :         bitmap_set_bit (regular_block_artificial_uses, HARD_FRAME_POINTER_REGNUM);
    3370                 :            :     }
    3371                 :            :   else
    3372                 :            :     /* Before reload, there are a few registers that must be forced
    3373                 :            :        live everywhere -- which might not already be the case for
    3374                 :            :        blocks within infinite loops.  */
    3375                 :            :     {
    3376                 :    2675980 :       unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
    3377                 :            : 
    3378                 :            :       /* Any reference to any pseudo before reload is a potential
    3379                 :            :          reference of the frame pointer.  */
    3380                 :    2675980 :       bitmap_set_bit (regular_block_artificial_uses, FRAME_POINTER_REGNUM);
    3381                 :            : 
    3382                 :    2675980 :       if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
    3383                 :    2675980 :         bitmap_set_bit (regular_block_artificial_uses,
    3384                 :            :                         HARD_FRAME_POINTER_REGNUM);
    3385                 :            : 
    3386                 :            :       /* Pseudos with argument area equivalences may require
    3387                 :            :          reloading via the argument pointer.  */
    3388                 :    2675980 :       if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3389                 :    2675980 :           && fixed_regs[ARG_POINTER_REGNUM])
    3390                 :    2675980 :         bitmap_set_bit (regular_block_artificial_uses, ARG_POINTER_REGNUM);
    3391                 :            : 
    3392                 :            :       /* Any constant, or pseudo with constant equivalences, may
    3393                 :            :          require reloading from memory using the pic register.  */
    3394                 :    2675980 :       if (picreg != INVALID_REGNUM
    3395                 :          0 :           && fixed_regs[picreg])
    3396                 :          0 :         bitmap_set_bit (regular_block_artificial_uses, picreg);
    3397                 :            :     }
    3398                 :            :   /* The all-important stack pointer must always be live.  */
    3399                 :    6004870 :   bitmap_set_bit (regular_block_artificial_uses, STACK_POINTER_REGNUM);
    3400                 :            : 
    3401                 :            : #ifdef EH_USES
    3402                 :            :   /* EH_USES registers are used:
    3403                 :            :      1) at all insns that might throw (calls or with -fnon-call-exceptions
    3404                 :            :         trapping insns)
    3405                 :            :      2) in all EH edges
    3406                 :            :      3) to support backtraces and/or debugging, anywhere between their
    3407                 :            :         initialization and where they the saved registers are restored
    3408                 :            :         from them, including the cases where we don't reach the epilogue
    3409                 :            :         (noreturn call or infinite loop).  */
    3410                 :            :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3411                 :            :     if (EH_USES (i))
    3412                 :            :       bitmap_set_bit (regular_block_artificial_uses, i);
    3413                 :            : #endif
    3414                 :    6004870 : }
    3415                 :            : 
    3416                 :            : 
    3417                 :            : /* Get the artificial use set for an eh block. */
    3418                 :            : 
    3419                 :            : static void
    3420                 :    6004870 : df_get_eh_block_artificial_uses (bitmap eh_block_artificial_uses)
    3421                 :            : {
    3422                 :    6004870 :   bitmap_clear (eh_block_artificial_uses);
    3423                 :            : 
    3424                 :            :   /* The following code (down through the arg_pointer setting APPEARS
    3425                 :            :      to be necessary because there is nothing that actually
    3426                 :            :      describes what the exception handling code may actually need
    3427                 :            :      to keep alive.  */
    3428                 :    6004870 :   if (reload_completed)
    3429                 :            :     {
    3430                 :    3328890 :       if (frame_pointer_needed)
    3431                 :            :         {
    3432                 :     721904 :           bitmap_set_bit (eh_block_artificial_uses, FRAME_POINTER_REGNUM);
    3433                 :     721904 :           if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
    3434                 :     721904 :             bitmap_set_bit (eh_block_artificial_uses,
    3435                 :            :                             HARD_FRAME_POINTER_REGNUM);
    3436                 :            :         }
    3437                 :    3328890 :       if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3438                 :    3328890 :           && fixed_regs[ARG_POINTER_REGNUM])
    3439                 :    3328890 :         bitmap_set_bit (eh_block_artificial_uses, ARG_POINTER_REGNUM);
    3440                 :            :     }
    3441                 :    6004870 : }
    3442                 :            : 
    3443                 :            : 
    3444                 :            : 
    3445                 :            : /*----------------------------------------------------------------------------
    3446                 :            :    Specialized hard register scanning functions.
    3447                 :            : ----------------------------------------------------------------------------*/
    3448                 :            : 
    3449                 :            : 
    3450                 :            : /* Mark a register in SET.  Hard registers in large modes get all
    3451                 :            :    of their component registers set as well.  */
    3452                 :            : 
    3453                 :            : static void
    3454                 :    5616630 : df_mark_reg (rtx reg, void *vset)
    3455                 :            : {
    3456                 :    5616360 :   bitmap_set_range ((bitmap) vset, REGNO (reg), REG_NREGS (reg));
    3457                 :        274 : }
    3458                 :            : 
    3459                 :            : 
    3460                 :            : /* Set the bit for regs that are considered being defined at the entry. */
    3461                 :            : 
    3462                 :            : static void
    3463                 :    9641780 : df_get_entry_block_def_set (bitmap entry_block_defs)
    3464                 :            : {
    3465                 :    9641780 :   rtx r;
    3466                 :    9641780 :   int i;
    3467                 :            : 
    3468                 :    9641780 :   bitmap_clear (entry_block_defs);
    3469                 :            : 
    3470                 :            :   /* For separate shrink-wrapping we use LIVE to analyze which basic blocks
    3471                 :            :      need a prologue for some component to be executed before that block,
    3472                 :            :      and we do not care about any other registers.  Hence, we do not want
    3473                 :            :      any register for any component defined in the entry block, and we can
    3474                 :            :      just leave all registers undefined.  */
    3475                 :    9641780 :   if (df_scan->local_flags & DF_SCAN_EMPTY_ENTRY_EXIT)
    3476                 :            :     return;
    3477                 :            : 
    3478                 :  742417000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3479                 :            :     {
    3480                 :  732776000 :       if (global_regs[i])
    3481                 :        637 :         bitmap_set_bit (entry_block_defs, i);
    3482                 :  732776000 :       if (FUNCTION_ARG_REGNO_P (i))
    3483                 :  137126000 :         bitmap_set_bit (entry_block_defs, INCOMING_REGNO (i));
    3484                 :            :     }
    3485                 :            : 
    3486                 :            :   /* The always important stack pointer.  */
    3487                 :    9641780 :   bitmap_set_bit (entry_block_defs, STACK_POINTER_REGNUM);
    3488                 :            : 
    3489                 :            :   /* Once the prologue has been generated, all of these registers
    3490                 :            :      should just show up in the first regular block.  */
    3491                 :    9641780 :   if (targetm.have_prologue () && epilogue_completed)
    3492                 :            :     {
    3493                 :            :       /* Defs for the callee saved registers are inserted so that the
    3494                 :            :          pushes have some defining location.  */
    3495                 :  142125000 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3496                 :  140280000 :         if (!crtl->abi->clobbers_full_reg_p (i)
    3497                 :   16507800 :             && !fixed_regs[i]
    3498                 :  151239000 :             && df_regs_ever_live_p (i))
    3499                 :    2513420 :           bitmap_set_bit (entry_block_defs, i);
    3500                 :            :     }
    3501                 :            : 
    3502                 :    9641780 :   r = targetm.calls.struct_value_rtx (current_function_decl, true);
    3503                 :    9641780 :   if (r && REG_P (r))
    3504                 :          0 :     bitmap_set_bit (entry_block_defs, REGNO (r));
    3505                 :            : 
    3506                 :            :   /* If the function has an incoming STATIC_CHAIN, it has to show up
    3507                 :            :      in the entry def set.  */
    3508                 :    9641780 :   r = rtx_for_static_chain (current_function_decl, true);
    3509                 :    9641780 :   if (r && REG_P (r))
    3510                 :     157234 :     bitmap_set_bit (entry_block_defs, REGNO (r));
    3511                 :            : 
    3512                 :    9641780 :   if ((!reload_completed) || frame_pointer_needed)
    3513                 :            :     {
    3514                 :            :       /* Any reference to any pseudo before reload is a potential
    3515                 :            :          reference of the frame pointer.  */
    3516                 :    5782780 :       bitmap_set_bit (entry_block_defs, FRAME_POINTER_REGNUM);
    3517                 :            : 
    3518                 :            :       /* If they are different, also mark the hard frame pointer as live.  */
    3519                 :    5782780 :       if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
    3520                 :            :           && !LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
    3521                 :    5782780 :         bitmap_set_bit (entry_block_defs, HARD_FRAME_POINTER_REGNUM);
    3522                 :            :     }
    3523                 :            : 
    3524                 :            :   /* These registers are live everywhere.  */
    3525                 :    9641780 :   if (!reload_completed)
    3526                 :            :     {
    3527                 :            :       /* Pseudos with argument area equivalences may require
    3528                 :            :          reloading via the argument pointer.  */
    3529                 :    4547960 :       if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3530                 :    4547960 :           && fixed_regs[ARG_POINTER_REGNUM])
    3531                 :    4547960 :         bitmap_set_bit (entry_block_defs, ARG_POINTER_REGNUM);
    3532                 :            : 
    3533                 :            :       /* Any constant, or pseudo with constant equivalences, may
    3534                 :            :          require reloading from memory using the pic register.  */
    3535                 :    4547960 :       unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
    3536                 :          0 :       if (picreg != INVALID_REGNUM
    3537                 :          0 :           && fixed_regs[picreg])
    3538                 :          0 :         bitmap_set_bit (entry_block_defs, picreg);
    3539                 :            :     }
    3540                 :            : 
    3541                 :            : #ifdef INCOMING_RETURN_ADDR_RTX
    3542                 :   10699600 :   if (REG_P (INCOMING_RETURN_ADDR_RTX))
    3543                 :          0 :     bitmap_set_bit (entry_block_defs, REGNO (INCOMING_RETURN_ADDR_RTX));
    3544                 :            : #endif
    3545                 :            : 
    3546                 :    9641780 :   targetm.extra_live_on_entry (entry_block_defs);
    3547                 :            : }
    3548                 :            : 
    3549                 :            : 
    3550                 :            : /* Return the (conservative) set of hard registers that are defined on
    3551                 :            :    entry to the function.
    3552                 :            :    It uses df->entry_block_defs to determine which register
    3553                 :            :    reference to include.  */
    3554                 :            : 
    3555                 :            : static void
    3556                 :    6861820 : df_entry_block_defs_collect (class df_collection_rec *collection_rec,
    3557                 :            :                              bitmap entry_block_defs)
    3558                 :            : {
    3559                 :    6861820 :   unsigned int i;
    3560                 :    6861820 :   bitmap_iterator bi;
    3561                 :            : 
    3562                 :  122926000 :   EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
    3563                 :            :     {
    3564                 :  116064000 :       df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
    3565                 :  116064000 :                      ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_DEF, 0);
    3566                 :            :     }
    3567                 :            : 
    3568                 :    6861820 :   df_canonize_collection_rec (collection_rec);
    3569                 :    6861820 : }
    3570                 :            : 
    3571                 :            : 
    3572                 :            : /* Record the (conservative) set of hard registers that are defined on
    3573                 :            :    entry to the function.  */
    3574                 :            : 
    3575                 :            : static void
    3576                 :    2817400 : df_record_entry_block_defs (bitmap entry_block_defs)
    3577                 :            : {
    3578                 :    5634800 :   class df_collection_rec collection_rec;
    3579                 :    2817400 :   df_entry_block_defs_collect (&collection_rec, entry_block_defs);
    3580                 :            : 
    3581                 :            :   /* Process bb_refs chain */
    3582                 :    5634800 :   df_refs_add_to_chains (&collection_rec,
    3583                 :    2817400 :                          BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK),
    3584                 :            :                          NULL,
    3585                 :            :                          copy_defs);
    3586                 :    2817400 : }
    3587                 :            : 
    3588                 :            : 
    3589                 :            : /* Update the defs in the entry block.  */
    3590                 :            : 
    3591                 :            : void
    3592                 :    3636910 : df_update_entry_block_defs (void)
    3593                 :            : {
    3594                 :    3636910 :   bool changed = false;
    3595                 :            : 
    3596                 :    3636910 :   auto_bitmap refs (&df_bitmap_obstack);
    3597                 :    3636910 :   df_get_entry_block_def_set (refs);
    3598                 :    3636910 :   gcc_assert (df->entry_block_defs);
    3599                 :    3636910 :   if (!bitmap_equal_p (df->entry_block_defs, refs))
    3600                 :            :     {
    3601                 :     856951 :       struct df_scan_bb_info *bb_info = df_scan_get_bb_info (ENTRY_BLOCK);
    3602                 :     856951 :       df_ref_chain_delete_du_chain (bb_info->artificial_defs);
    3603                 :     856951 :       df_ref_chain_delete (bb_info->artificial_defs);
    3604                 :     856951 :       bb_info->artificial_defs = NULL;
    3605                 :     856951 :       changed = true;
    3606                 :            :     }
    3607                 :            : 
    3608                 :     856951 :   if (changed)
    3609                 :            :     {
    3610                 :     856951 :       df_record_entry_block_defs (refs);
    3611                 :     856951 :       bitmap_copy (df->entry_block_defs, refs);
    3612                 :     856951 :       df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK));
    3613                 :            :     }
    3614                 :    3636910 : }
    3615                 :            : 
    3616                 :            : 
    3617                 :            : /* Set the bit for regs that are considered being used at the exit. */
    3618                 :            : 
    3619                 :            : static void
    3620                 :   10445300 : df_get_exit_block_use_set (bitmap exit_block_uses)
    3621                 :            : {
    3622                 :   10445300 :   unsigned int i;
    3623                 :   10445300 :   unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
    3624                 :            : 
    3625                 :   10445300 :   bitmap_clear (exit_block_uses);
    3626                 :            : 
    3627                 :            :   /* For separate shrink-wrapping we use LIVE to analyze which basic blocks
    3628                 :            :      need an epilogue for some component to be executed after that block,
    3629                 :            :      and we do not care about any other registers.  Hence, we do not want
    3630                 :            :      any register for any component seen as used in the exit block, and we
    3631                 :            :      can just say no registers at all are used.  */
    3632                 :   10445300 :   if (df_scan->local_flags & DF_SCAN_EMPTY_ENTRY_EXIT)
    3633                 :            :     return;
    3634                 :            : 
    3635                 :            :   /* Stack pointer is always live at the exit.  */
    3636                 :   10445300 :   bitmap_set_bit (exit_block_uses, STACK_POINTER_REGNUM);
    3637                 :            : 
    3638                 :            :   /* Mark the frame pointer if needed at the end of the function.
    3639                 :            :      If we end up eliminating it, it will be removed from the live
    3640                 :            :      list of each basic block by reload.  */
    3641                 :            : 
    3642                 :   10445300 :   if ((!reload_completed) || frame_pointer_needed)
    3643                 :            :     {
    3644                 :    6586290 :       bitmap_set_bit (exit_block_uses, FRAME_POINTER_REGNUM);
    3645                 :            : 
    3646                 :            :       /* If they are different, also mark the hard frame pointer as live.  */
    3647                 :    6586290 :       if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
    3648                 :            :           && !LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
    3649                 :    6586290 :         bitmap_set_bit (exit_block_uses, HARD_FRAME_POINTER_REGNUM);
    3650                 :            :     }
    3651                 :            : 
    3652                 :            :   /* Many architectures have a GP register even without flag_pic.
    3653                 :            :      Assume the pic register is not in use, or will be handled by
    3654                 :            :      other means, if it is not fixed.  */
    3655                 :   10445300 :   if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
    3656                 :            :       && picreg != INVALID_REGNUM
    3657                 :          0 :       && fixed_regs[picreg])
    3658                 :          0 :     bitmap_set_bit (exit_block_uses, picreg);
    3659                 :            : 
    3660                 :            :   /* Mark all global registers, and all registers used by the
    3661                 :            :      epilogue as being live at the end of the function since they
    3662                 :            :      may be referenced by our caller.  */
    3663                 :  804288000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3664                 :  793843000 :     if (global_regs[i] || EPILOGUE_USES (i))
    3665                 :       3542 :       bitmap_set_bit (exit_block_uses, i);
    3666                 :            : 
    3667                 :   10445300 :   if (targetm.have_epilogue () && epilogue_completed)
    3668                 :            :     {
    3669                 :            :       /* Mark all call-saved registers that we actually used.  */
    3670                 :  142125000 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3671                 :  140280000 :         if (df_regs_ever_live_p (i)
    3672                 :            :             && !LOCAL_REGNO (i)
    3673                 :  140280000 :             && !crtl->abi->clobbers_full_reg_p (i))
    3674                 :    3894370 :           bitmap_set_bit (exit_block_uses, i);
    3675                 :            :     }
    3676                 :            : 
    3677                 :            :   /* Mark the registers that will contain data for the handler.  */
    3678                 :   10445300 :   if (reload_completed && crtl->calls_eh_return)
    3679                 :        290 :     for (i = 0; ; ++i)
    3680                 :            :       {
    3681                 :        435 :         unsigned regno = EH_RETURN_DATA_REGNO (i);
    3682                 :        290 :         if (regno == INVALID_REGNUM)
    3683                 :            :           break;
    3684                 :        290 :         bitmap_set_bit (exit_block_uses, regno);
    3685                 :        290 :       }
    3686                 :            : 
    3687                 :            : #ifdef EH_RETURN_STACKADJ_RTX
    3688                 :   20890600 :   if ((!targetm.have_epilogue () || ! epilogue_completed)
    3689                 :   19044800 :       && crtl->calls_eh_return)
    3690                 :            :     {
    3691                 :        366 :       rtx tmp = EH_RETURN_STACKADJ_RTX;
    3692                 :        274 :       if (tmp && REG_P (tmp))
    3693                 :        274 :         df_mark_reg (tmp, exit_block_uses);
    3694                 :            :     }
    3695                 :            : #endif
    3696                 :            : 
    3697                 :   10445300 :   if ((!targetm.have_epilogue () || ! epilogue_completed)
    3698                 :            :       && crtl->calls_eh_return)
    3699                 :            :     {
    3700                 :   10445300 :       rtx tmp = EH_RETURN_HANDLER_RTX;
    3701                 :            :       if (tmp && REG_P (tmp))
    3702                 :   10445300 :         df_mark_reg (tmp, exit_block_uses);
    3703                 :            :     }
    3704                 :            : 
    3705                 :            :   /* Mark function return value.  */
    3706                 :   10445300 :   diddle_return_value (df_mark_reg, (void*) exit_block_uses);
    3707                 :            : }
    3708                 :            : 
    3709                 :            : 
    3710                 :            : /* Return the refs of hard registers that are used in the exit block.
    3711                 :            :    It uses df->exit_block_uses to determine register to include.  */
    3712                 :            : 
    3713                 :            : static void
    3714                 :    6664370 : df_exit_block_uses_collect (class df_collection_rec *collection_rec, bitmap exit_block_uses)
    3715                 :            : {
    3716                 :    6664370 :   unsigned int i;
    3717                 :    6664370 :   bitmap_iterator bi;
    3718                 :            : 
    3719                 :   25913200 :   EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
    3720                 :   19248800 :     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
    3721                 :   19248800 :                    EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_USE, 0);
    3722                 :            : 
    3723                 :            :   /* It is deliberate that this is not put in the exit block uses but
    3724                 :            :      I do not know why.  */
    3725                 :    6664370 :   if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3726                 :    6664370 :       && reload_completed
    3727                 :    3988390 :       && !bitmap_bit_p (exit_block_uses, ARG_POINTER_REGNUM)
    3728                 :    3988390 :       && bb_has_eh_pred (EXIT_BLOCK_PTR_FOR_FN (cfun))
    3729                 :    6664370 :       && fixed_regs[ARG_POINTER_REGNUM])
    3730                 :          0 :     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
    3731                 :          0 :                    EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_USE, 0);
    3732                 :            : 
    3733                 :    6664370 :   df_canonize_collection_rec (collection_rec);
    3734                 :    6664370 : }
    3735                 :            : 
    3736                 :            : 
    3737                 :            : /* Record the set of hard registers that are used in the exit block.
    3738                 :            :    It uses df->exit_block_uses to determine which bit to include.  */
    3739                 :            : 
    3740                 :            : static void
    3741                 :    2619950 : df_record_exit_block_uses (bitmap exit_block_uses)
    3742                 :            : {
    3743                 :    5239890 :   class df_collection_rec collection_rec;
    3744                 :    2619950 :   df_exit_block_uses_collect (&collection_rec, exit_block_uses);
    3745                 :            : 
    3746                 :            :   /* Process bb_refs chain */
    3747                 :    5239890 :   df_refs_add_to_chains (&collection_rec,
    3748                 :    2619950 :                          BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK),
    3749                 :            :                          NULL,
    3750                 :            :                          copy_uses);
    3751                 :    2619950 : }
    3752                 :            : 
    3753                 :            : 
    3754                 :            : /* Update the uses in the exit block.  */
    3755                 :            : 
    3756                 :            : void
    3757                 :    4440430 : df_update_exit_block_uses (void)
    3758                 :            : {
    3759                 :    4440430 :   bool changed = false;
    3760                 :            : 
    3761                 :    4440430 :   auto_bitmap refs (&df_bitmap_obstack);
    3762                 :    4440430 :   df_get_exit_block_use_set (refs);
    3763                 :    4440430 :   gcc_assert (df->exit_block_uses);
    3764                 :    4440430 :   if (!bitmap_equal_p (df->exit_block_uses, refs))
    3765                 :            :     {
    3766                 :     659497 :       struct df_scan_bb_info *bb_info = df_scan_get_bb_info (EXIT_BLOCK);
    3767                 :     659497 :       df_ref_chain_delete_du_chain (bb_info->artificial_uses);
    3768                 :     659497 :       df_ref_chain_delete (bb_info->artificial_uses);
    3769                 :     659497 :       bb_info->artificial_uses = NULL;
    3770                 :     659497 :       changed = true;
    3771                 :            :     }
    3772                 :            : 
    3773                 :     659497 :   if (changed)
    3774                 :            :     {
    3775                 :     659497 :       df_record_exit_block_uses (refs);
    3776                 :     659497 :       bitmap_copy (df->exit_block_uses, refs);
    3777                 :     659497 :       df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK));
    3778                 :            :     }
    3779                 :    4440430 : }
    3780                 :            : 
    3781                 :            : static bool initialized = false;
    3782                 :            : 
    3783                 :            : 
    3784                 :            : /* Initialize some platform specific structures.  */
    3785                 :            : 
    3786                 :            : void
    3787                 :     944099 : df_hard_reg_init (void)
    3788                 :            : {
    3789                 :     944099 :   int i;
    3790                 :     944099 :   static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
    3791                 :            : 
    3792                 :     944099 :   if (initialized)
    3793                 :            :     return;
    3794                 :            : 
    3795                 :            :   /* Record which registers will be eliminated.  We use this in
    3796                 :            :      mark_used_regs.  */
    3797                 :     446127 :   CLEAR_HARD_REG_SET (elim_reg_set);
    3798                 :            : 
    3799                 :     743545 :   for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
    3800                 :     594836 :     SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);
    3801                 :            : 
    3802                 :     148709 :   initialized = true;
    3803                 :            : }
    3804                 :            : 
    3805                 :            : 
    3806                 :            : /* Recompute the parts of scanning that are based on regs_ever_live
    3807                 :            :    because something changed in that array.  */
    3808                 :            : 
    3809                 :            : void
    3810                 :    3636910 : df_update_entry_exit_and_calls (void)
    3811                 :            : {
    3812                 :    3636910 :   basic_block bb;
    3813                 :            : 
    3814                 :    3636910 :   df_update_entry_block_defs ();
    3815                 :    3636910 :   df_update_exit_block_uses ();
    3816                 :            : 
    3817                 :            :   /* The call insns need to be rescanned because there may be changes
    3818                 :            :      in the set of registers clobbered across the call.  */
    3819                 :   41897100 :   FOR_EACH_BB_FN (bb, cfun)
    3820                 :            :     {
    3821                 :   38260200 :       rtx_insn *insn;
    3822                 :  862100000 :       FOR_BB_INSNS (bb, insn)
    3823                 :            :         {
    3824                 :  411920000 :           if (INSN_P (insn) && CALL_P (insn))
    3825                 :   16666000 :             df_insn_rescan (insn);
    3826                 :            :         }
    3827                 :            :     }
    3828                 :    3636910 : }
    3829                 :            : 
    3830                 :            : 
    3831                 :            : /* Return true if hard REG is actually used in the some instruction.
    3832                 :            :    There are a fair number of conditions that affect the setting of
    3833                 :            :    this array.  See the comment in df.h for df->hard_regs_live_count
    3834                 :            :    for the conditions that this array is set. */
    3835                 :            : 
    3836                 :            : bool
    3837                 : 1866850000 : df_hard_reg_used_p (unsigned int reg)
    3838                 :            : {
    3839                 : 1866850000 :   return df->hard_regs_live_count[reg] != 0;
    3840                 :            : }
    3841                 :            : 
    3842                 :            : 
    3843                 :            : /* A count of the number of times REG is actually used in the some
    3844                 :            :    instruction.  There are a fair number of conditions that affect the
    3845                 :            :    setting of this array.  See the comment in df.h for
    3846                 :            :    df->hard_regs_live_count for the conditions that this array is
    3847                 :            :    set. */
    3848                 :            : 
    3849                 :            : 
    3850                 :            : unsigned int
    3851                 :          0 : df_hard_reg_used_count (unsigned int reg)
    3852                 :            : {
    3853                 :          0 :   return df->hard_regs_live_count[reg];
    3854                 :            : }
    3855                 :            : 
    3856                 :            : 
    3857                 :            : /* Get the value of regs_ever_live[REGNO].  */
    3858                 :            : 
    3859                 :            : bool
    3860                 :  336156000 : df_regs_ever_live_p (unsigned int regno)
    3861                 :            : {
    3862                 :  336156000 :   return regs_ever_live[regno];
    3863                 :            : }
    3864                 :            : 
    3865                 :            : 
    3866                 :            : /* Set regs_ever_live[REGNO] to VALUE.  If this cause regs_ever_live
    3867                 :            :    to change, schedule that change for the next update.  */
    3868                 :            : 
    3869                 :            : void
    3870                 :   62096400 : df_set_regs_ever_live (unsigned int regno, bool value)
    3871                 :            : {
    3872                 :   62096400 :   if (regs_ever_live[regno] == value)
    3873                 :            :     return;
    3874                 :            : 
    3875                 :    2343540 :   regs_ever_live[regno] = value;
    3876                 :    2343540 :   if (df)
    3877                 :    2343540 :     df->redo_entry_and_exit = true;
    3878                 :            : }
    3879                 :            : 
    3880                 :            : 
    3881                 :            : /* Compute "regs_ever_live" information from the underlying df
    3882                 :            :    information.  Set the vector to all false if RESET.  */
    3883                 :            : 
    3884                 :            : void
    3885                 :   26289800 : df_compute_regs_ever_live (bool reset)
    3886                 :            : {
    3887                 :   26289800 :   unsigned int i;
    3888                 :   26289800 :   bool changed = df->redo_entry_and_exit;
    3889                 :            : 
    3890                 :   26289800 :   if (reset)
    3891                 :    1656640 :     memset (regs_ever_live, 0, sizeof (regs_ever_live));
    3892                 :            : 
    3893                 : 2024310000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3894                 : 1998020000 :     if ((!regs_ever_live[i]) && df_hard_reg_used_p (i))
    3895                 :            :       {
    3896                 :    7522930 :         regs_ever_live[i] = true;
    3897                 :    7522930 :         changed = true;
    3898                 :            :       }
    3899                 :   26289800 :   if (changed)
    3900                 :    2113650 :     df_update_entry_exit_and_calls ();
    3901                 :   26289800 :   df->redo_entry_and_exit = false;
    3902                 :   26289800 : }
    3903                 :            : 
    3904                 :            : 
    3905                 :            : /*----------------------------------------------------------------------------
    3906                 :            :   Dataflow ref information verification functions.
    3907                 :            : 
    3908                 :            :   df_reg_chain_mark (refs, regno, is_def, is_eq_use)
    3909                 :            :   df_reg_chain_verify_unmarked (refs)
    3910                 :            :   df_refs_verify (vec<stack, va_df_ref>, ref*, bool)
    3911                 :            :   df_mws_verify (mw*, mw*, bool)
    3912                 :            :   df_insn_refs_verify (collection_rec, bb, insn, bool)
    3913                 :            :   df_bb_refs_verify (bb, refs, bool)
    3914                 :            :   df_bb_verify (bb)
    3915                 :            :   df_exit_block_bitmap_verify (bool)
    3916                 :            :   df_entry_block_bitmap_verify (bool)
    3917                 :            :   df_scan_verify ()
    3918                 :            : ----------------------------------------------------------------------------*/
    3919                 :            : 
    3920                 :            : 
    3921                 :            : /* Mark all refs in the reg chain.  Verify that all of the registers
    3922                 :            : are in the correct chain.  */
    3923                 :            : 
    3924                 :            : static unsigned int
    3925                 : 1518670000 : df_reg_chain_mark (df_ref refs, unsigned int regno,
    3926                 :            :                    bool is_def, bool is_eq_use)
    3927                 :            : {
    3928                 : 1518670000 :   unsigned int count = 0;
    3929                 : 1518670000 :   df_ref ref;
    3930                 : 3398850000 :   for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
    3931                 :            :     {
    3932                 : 1880170000 :       gcc_assert (!DF_REF_IS_REG_MARKED (ref));
    3933                 :            : 
    3934                 :            :       /* If there are no def-use or use-def chains, make sure that all
    3935                 :            :          of the chains are clear.  */
    3936                 : 1880170000 :       if (!df_chain)
    3937                 : 1857730000 :         gcc_assert (!DF_REF_CHAIN (ref));
    3938                 :            : 
    3939                 :            :       /* Check to make sure the ref is in the correct chain.  */
    3940                 : 1880170000 :       gcc_assert (DF_REF_REGNO (ref) == regno);
    3941                 : 1880170000 :       if (is_def)
    3942                 : 1448160000 :         gcc_assert (DF_REF_REG_DEF_P (ref));
    3943                 :            :       else
    3944                 :  432017000 :         gcc_assert (!DF_REF_REG_DEF_P (ref));
    3945                 :            : 
    3946                 : 1880170000 :       if (is_eq_use)
    3947                 :    9827390 :         gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE));
    3948                 :            :       else
    3949                 : 1870350000 :         gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) == 0);
    3950                 :            : 
    3951                 : 1880170000 :       if (DF_REF_NEXT_REG (ref))
    3952                 : 1567800000 :         gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref)) == ref);
    3953                 : 1880170000 :       count++;
    3954                 : 1880170000 :       DF_REF_REG_MARK (ref);
    3955                 :            :     }
    3956                 : 1518670000 :   return count;
    3957                 :            : }
    3958                 :            : 
    3959                 :            : 
    3960                 :            : /* Verify that all of the registers in the chain are unmarked.  */
    3961                 :            : 
    3962                 :            : static void
    3963                 : 1518670000 : df_reg_chain_verify_unmarked (df_ref refs)
    3964                 :            : {
    3965                 : 1518670000 :   df_ref ref;
    3966                 : 3398850000 :   for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
    3967                 : 1880170000 :     gcc_assert (!DF_REF_IS_REG_MARKED (ref));
    3968                 : 1518670000 : }
    3969                 :            : 
    3970                 :            : 
    3971                 :            : /* Verify that NEW_REC and OLD_REC have exactly the same members. */
    3972                 :            : 
    3973                 :            : static bool
    3974                 : 1379020000 : df_refs_verify (const vec<df_ref, va_heap> *new_rec, df_ref old_rec,
    3975                 :            :                 bool abort_if_fail)
    3976                 :            : {
    3977                 : 1379020000 :   unsigned int ix;
    3978                 : 1379020000 :   df_ref new_ref;
    3979                 :            : 
    3980                 : 4453710000 :   FOR_EACH_VEC_ELT (*new_rec, ix, new_ref)
    3981                 :            :     {
    3982                 : 3102810000 :       if (old_rec == NULL || !df_ref_equal_p (new_ref, old_rec))
    3983                 :            :         {
    3984                 :   28119800 :           if (abort_if_fail)
    3985                 :          0 :             gcc_assert (0);
    3986                 :            :           else
    3987                 :            :             return false;
    3988                 :            :         }
    3989                 :            : 
    3990                 :            :       /* Abort if fail is called from the function level verifier.  If
    3991                 :            :          that is the context, mark this reg as being seem.  */
    3992                 : 3074690000 :       if (abort_if_fail)
    3993                 :            :         {
    3994                 : 1880170000 :           gcc_assert (DF_REF_IS_REG_MARKED (old_rec));
    3995                 : 1880170000 :           DF_REF_REG_UNMARK (old_rec);
    3996                 :            :         }
    3997                 :            : 
    3998                 : 3074690000 :       old_rec = DF_REF_NEXT_LOC (old_rec);
    3999                 :            :     }
    4000                 :            : 
    4001                 : 1350900000 :   if (abort_if_fail)
    4002                 : 1231860000 :     gcc_assert (old_rec == NULL);
    4003                 :            :   else
    4004                 :  119044000 :     return old_rec == NULL;
    4005                 :            :   return false;
    4006                 :            : }
    4007                 :            : 
    4008                 :            : 
    4009                 :            : /* Verify that NEW_REC and OLD_REC have exactly the same members. */
    4010                 :            : 
    4011                 :            : static bool
    4012                 :  408090000 : df_mws_verify (const vec<df_mw_hardreg *, va_heap> *new_rec,
    4013                 :            :                struct df_mw_hardreg *old_rec,
    4014                 :            :                bool abort_if_fail)
    4015                 :            : {
    4016                 :  408090000 :   unsigned int ix;
    4017                 :  408090000 :   struct df_mw_hardreg *new_reg;
    4018                 :            : 
    4019                 :  410577000 :   FOR_EACH_VEC_ELT (*new_rec, ix, new_reg)
    4020                 :            :     {
    4021                 :    2487260 :       if (old_rec == NULL || !df_mw_equal_p (new_reg, old_rec))
    4022                 :            :         {
    4023                 :          0 :           if (abort_if_fail)
    4024                 :          0 :             gcc_assert (0);
    4025                 :            :           else
    4026                 :            :             return false;
    4027                 :            :         }
    4028                 :    2487260 :       old_rec = DF_MWS_NEXT (old_rec);
    4029                 :            :     }
    4030                 :            : 
    4031                 :  408090000 :   if (abort_if_fail)
    4032                 :  378087000 :     gcc_assert (old_rec == NULL);
    4033                 :            :   else
    4034                 :   30002700 :     return old_rec == NULL;
    4035                 :            :   return false;
    4036                 :            : }
    4037                 :            : 
    4038                 :            : 
    4039                 :            : /* Return true if the existing insn refs information is complete and
    4040                 :            :    correct. Otherwise (i.e. if there's any missing or extra refs),
    4041                 :            :    return the correct df_ref chain in REFS_RETURN.
    4042                 :            : 
    4043                 :            :    If ABORT_IF_FAIL, leave the refs that are verified (already in the
    4044                 :            :    ref chain) as DF_REF_MARKED(). If it's false, then it's a per-insn
    4045                 :            :    verification mode instead of the whole function, so unmark
    4046                 :            :    everything.
    4047                 :            : 
    4048                 :            :    If ABORT_IF_FAIL is set, this function never returns false.  */
    4049                 :            : 
    4050                 :            : static bool
    4051                 :  438612000 : df_insn_refs_verify (class df_collection_rec *collection_rec,
    4052                 :            :                      basic_block bb,
    4053                 :            :                      rtx_insn *insn,
    4054                 :            :                      bool abort_if_fail)
    4055                 :            : {
    4056                 :  438612000 :   bool ret1, ret2, ret3;
    4057                 :  438612000 :   unsigned int uid = INSN_UID (insn);
    4058                 :  438612000 :   struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4059                 :            : 
    4060                 :  438612000 :   df_insn_refs_collect (collection_rec, bb, insn_info);
    4061                 :            : 
    4062                 :            :   /* Unfortunately we cannot opt out early if one of these is not
    4063                 :            :      right and abort_if_fail is set because the marks will not get cleared.  */
    4064                 :  438612000 :   ret1 = df_refs_verify (&collection_rec->def_vec, DF_INSN_UID_DEFS (uid),
    4065                 :            :                          abort_if_fail);
    4066                 :  438612000 :   if (!ret1 && !abort_if_fail)
    4067                 :            :     return false;
    4068                 :  434602000 :   ret2 = df_refs_verify (&collection_rec->use_vec, DF_INSN_UID_USES (uid),
    4069                 :            :                          abort_if_fail);
    4070                 :  434602000 :   if (!ret2 && !abort_if_fail)
    4071                 :            :     return false;
    4072                 :  408211000 :   ret3 = df_refs_verify (&collection_rec->eq_use_vec, DF_INSN_UID_EQ_USES (uid),
    4073                 :            :                          abort_if_fail);
    4074                 :  408211000 :   if (!ret3 && !abort_if_fail)
    4075                 :            :     return false;
    4076                 :  408090000 :   if (! df_mws_verify (&collection_rec->mw_vec, DF_INSN_UID_MWS (uid),
    4077                 :            :                        abort_if_fail))
    4078                 :            :     return false;
    4079                 :   30002700 :   return (ret1 && ret2 && ret3);
    4080                 :            : }
    4081                 :            : 
    4082                 :            : 
    4083                 :            : /* Return true if all refs in the basic block are correct and complete.
    4084                 :            :    Due to df_ref_chain_verify, it will cause all refs
    4085                 :            :    that are verified to have DF_REF_MARK bit set.  */
    4086                 :            : 
    4087                 :            : static bool
    4088                 :   48799300 : df_bb_verify (basic_block bb)
    4089                 :            : {
    4090                 :   48799300 :   rtx_insn *insn;
    4091                 :   48799300 :   struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
    4092                 :   48799300 :   class df_collection_rec collection_rec;
    4093                 :            : 
    4094                 :   48799300 :   gcc_assert (bb_info);
    4095                 :            : 
    4096                 :            :   /* Scan the block, one insn at a time, from beginning to end.  */
    4097                 :  964892000 :   FOR_BB_INSNS_REVERSE (bb, insn)
    4098                 :            :     {
    4099                 :  458046000 :       if (!INSN_P (insn))
    4100                 :   79959300 :         continue;
    4101                 :  378087000 :       df_insn_refs_verify (&collection_rec, bb, insn, true);
    4102                 :  378087000 :       df_free_collection_rec (&collection_rec);
    4103                 :            :     }
    4104                 :            : 
    4105                 :            :   /* Do the artificial defs and uses.  */
    4106                 :   48799300 :   df_bb_refs_collect (&collection_rec, bb);
    4107                 :   97598600 :   df_refs_verify (&collection_rec.def_vec, df_get_artificial_defs (bb->index), true);
    4108                 :   97598600 :   df_refs_verify (&collection_rec.use_vec, df_get_artificial_uses (bb->index), true);
    4109                 :   48799300 :   df_free_collection_rec (&collection_rec);
    4110                 :            : 
    4111                 :   48799300 :   return true;
    4112                 :            : }
    4113                 :            : 
    4114                 :            : 
    4115                 :            : /* Returns true if the entry block has correct and complete df_ref set.
    4116                 :            :    If not it either aborts if ABORT_IF_FAIL is true or returns false.  */
    4117                 :            : 
    4118                 :            : static bool
    4119                 :    4044420 : df_entry_block_bitmap_verify (bool abort_if_fail)
    4120                 :            : {
    4121                 :    4044420 :   bool is_eq;
    4122                 :            : 
    4123                 :    4044420 :   auto_bitmap entry_block_defs (&df_bitmap_obstack);
    4124                 :    4044420 :   df_get_entry_block_def_set (entry_block_defs);
    4125                 :            : 
    4126                 :    4044420 :   is_eq = bitmap_equal_p (entry_block_defs, df->entry_block_defs);
    4127                 :            : 
    4128                 :    4044420 :   if (!is_eq && abort_if_fail)
    4129                 :            :     {
    4130                 :          0 :       fprintf (stderr, "entry_block_defs = ");
    4131                 :          0 :       df_print_regset (stderr, entry_block_defs);
    4132                 :          0 :       fprintf (stderr, "df->entry_block_defs = ");
    4133                 :          0 :       df_print_regset (stderr, df->entry_block_defs);
    4134                 :          0 :       gcc_assert (0);
    4135                 :            :     }
    4136                 :            : 
    4137                 :    4044420 :   return is_eq;
    4138                 :            : }
    4139                 :            : 
    4140                 :            : 
    4141                 :            : /* Returns true if the exit block has correct and complete df_ref set.
    4142                 :            :    If not it either aborts if ABORT_IF_FAIL is true or returns false. */
    4143                 :            : 
    4144                 :            : static bool
    4145                 :    4044420 : df_exit_block_bitmap_verify (bool abort_if_fail)
    4146                 :            : {
    4147                 :    4044420 :   bool is_eq;
    4148                 :            : 
    4149                 :    4044420 :   auto_bitmap exit_block_uses (&df_bitmap_obstack);
    4150                 :    4044420 :   df_get_exit_block_use_set (exit_block_uses);
    4151                 :            : 
    4152                 :    4044420 :   is_eq = bitmap_equal_p (exit_block_uses, df->exit_block_uses);
    4153                 :            : 
    4154                 :    4044420 :   if (!is_eq && abort_if_fail)
    4155                 :            :     {
    4156                 :          0 :       fprintf (stderr, "exit_block_uses = ");
    4157                 :          0 :       df_print_regset (stderr, exit_block_uses);
    4158                 :          0 :       fprintf (stderr, "df->exit_block_uses = ");
    4159                 :          0 :       df_print_regset (stderr, df->exit_block_uses);
    4160                 :          0 :       gcc_assert (0);
    4161                 :            :     }
    4162                 :            : 
    4163                 :    4044420 :   return is_eq;
    4164                 :            : }
    4165                 :            : 
    4166                 :            : 
    4167                 :            : /* Return true if df_ref information for all insns in all blocks are
    4168                 :            :    correct and complete.  */
    4169                 :            : 
    4170                 :            : void
    4171                 :    4044420 : df_scan_verify (void)
    4172                 :            : {
    4173                 :    4044420 :   unsigned int i;
    4174                 :    4044420 :   basic_block bb;
    4175                 :            : 
    4176                 :    4044420 :   if (!df)
    4177                 :          0 :     return;
    4178                 :            : 
    4179                 :            :   /* Verification is a 4 step process. */
    4180                 :            : 
    4181                 :            :   /* (1) All of the refs are marked by going through the reg chains.  */
    4182                 :  510268000 :   for (i = 0; i < DF_REG_SIZE (df); i++)
    4183                 :            :     {
    4184                 :  506224000 :       gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false)
    4185                 :            :                   == DF_REG_DEF_COUNT (i));
    4186                 :  506224000 :       gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i), i, false, false)
    4187                 :            :                   == DF_REG_USE_COUNT (i));
    4188                 :  506224000 :       gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i), i, false, true)
    4189                 :            :                   == DF_REG_EQ_USE_COUNT (i));
    4190                 :            :     }
    4191                 :            : 
    4192                 :            :   /* (2) There are various bitmaps whose value may change over the
    4193                 :            :      course of the compilation.  This step recomputes them to make
    4194                 :            :      sure that they have not slipped out of date.  */
    4195                 :    8088850 :   auto_bitmap regular_block_artificial_uses (&df_bitmap_obstack);
    4196                 :    4044420 :   auto_bitmap eh_block_artificial_uses (&df_bitmap_obstack);
    4197                 :            : 
    4198                 :    4044420 :   df_get_regular_block_artificial_uses (regular_block_artificial_uses);
    4199                 :    4044420 :   df_get_eh_block_artificial_uses (eh_block_artificial_uses);
    4200                 :            : 
    4201                 :    4044420 :   bitmap_ior_into (eh_block_artificial_uses,
    4202                 :    4044420 :                    regular_block_artificial_uses);
    4203                 :            : 
    4204                 :            :   /* Check artificial_uses bitmaps didn't change. */
    4205                 :    4044420 :   gcc_assert (bitmap_equal_p (regular_block_artificial_uses,
    4206                 :            :                               &df->regular_block_artificial_uses));
    4207                 :    4044420 :   gcc_assert (bitmap_equal_p (eh_block_artificial_uses,
    4208                 :            :                               &df->eh_block_artificial_uses));
    4209                 :            : 
    4210                 :            :   /* Verify entry block and exit block. These only verify the bitmaps,
    4211                 :            :      the refs are verified in df_bb_verify.  */
    4212                 :    4044420 :   df_entry_block_bitmap_verify (true);
    4213                 :    4044420 :   df_exit_block_bitmap_verify (true);
    4214                 :            : 
    4215                 :            :   /* (3) All of the insns in all of the blocks are traversed and the
    4216                 :            :      marks are cleared both in the artificial refs attached to the
    4217                 :            :      blocks and the real refs inside the insns.  It is a failure to
    4218                 :            :      clear a mark that has not been set as this means that the ref in
    4219                 :            :      the block or insn was not in the reg chain.  */
    4220                 :            : 
    4221                 :   52843700 :   FOR_ALL_BB_FN (bb, cfun)
    4222                 :   48799300 :     df_bb_verify (bb);
    4223                 :            : 
    4224                 :            :   /* (4) See if all reg chains are traversed a second time.  This time
    4225                 :            :      a check is made that the marks are clear. A set mark would be a
    4226                 :            :      from a reg that is not in any insn or basic block.  */
    4227                 :            : 
    4228                 :  510268000 :   for (i = 0; i < DF_REG_SIZE (df); i++)
    4229                 :            :     {
    4230                 :  506224000 :       df_reg_chain_verify_unmarked (DF_REG_DEF_CHAIN (i));
    4231                 :  506224000 :       df_reg_chain_verify_unmarked (DF_REG_USE_CHAIN (i));
    4232                 :  506224000 :       df_reg_chain_verify_unmarked (DF_REG_EQ_USE_CHAIN (i));
    4233                 :            :     }
    4234                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.