LCOV - code coverage report
Current view: top level - gcc - sched-deps.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1758 2230 78.8 %
Date: 2020-03-28 11:57:23 Functions: 100 132 75.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Instruction scheduling pass.  This file computes dependencies between
       2                 :            :    instructions.
       3                 :            :    Copyright (C) 1992-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
       5                 :            :    and currently maintained by, Jim Wilson (wilson@cygnus.com)
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it under
      10                 :            : the terms of the GNU General Public License as published by the Free
      11                 :            : Software Foundation; either version 3, or (at your option) any later
      12                 :            : version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :            : for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : #include "config.h"
      24                 :            : #include "system.h"
      25                 :            : #include "coretypes.h"
      26                 :            : #include "backend.h"
      27                 :            : #include "target.h"
      28                 :            : #include "rtl.h"
      29                 :            : #include "tree.h"
      30                 :            : #include "df.h"
      31                 :            : #include "insn-config.h"
      32                 :            : #include "regs.h"
      33                 :            : #include "memmodel.h"
      34                 :            : #include "ira.h"
      35                 :            : #include "ira-int.h"
      36                 :            : #include "insn-attr.h"
      37                 :            : #include "cfgbuild.h"
      38                 :            : #include "sched-int.h"
      39                 :            : #include "cselib.h"
      40                 :            : #include "function-abi.h"
      41                 :            : 
      42                 :            : #ifdef INSN_SCHEDULING
      43                 :            : 
      44                 :            : /* Holds current parameters for the dependency analyzer.  */
      45                 :            : struct sched_deps_info_def *sched_deps_info;
      46                 :            : 
      47                 :            : /* The data is specific to the Haifa scheduler.  */
      48                 :            : vec<haifa_deps_insn_data_def>
      49                 :            :     h_d_i_d = vNULL;
      50                 :            : 
      51                 :            : /* Return the major type present in the DS.  */
      52                 :            : enum reg_note
      53                 :          0 : ds_to_dk (ds_t ds)
      54                 :            : {
      55                 :          0 :   if (ds & DEP_TRUE)
      56                 :            :     return REG_DEP_TRUE;
      57                 :            : 
      58                 :          0 :   if (ds & DEP_OUTPUT)
      59                 :            :     return REG_DEP_OUTPUT;
      60                 :            : 
      61                 :          0 :   if (ds & DEP_CONTROL)
      62                 :            :     return REG_DEP_CONTROL;
      63                 :            : 
      64                 :          0 :   gcc_assert (ds & DEP_ANTI);
      65                 :            : 
      66                 :            :   return REG_DEP_ANTI;
      67                 :            : }
      68                 :            : 
      69                 :            : /* Return equivalent dep_status.  */
      70                 :            : ds_t
      71                 :          0 : dk_to_ds (enum reg_note dk)
      72                 :            : {
      73                 :          0 :   switch (dk)
      74                 :            :     {
      75                 :            :     case REG_DEP_TRUE:
      76                 :            :       return DEP_TRUE;
      77                 :            : 
      78                 :          0 :     case REG_DEP_OUTPUT:
      79                 :          0 :       return DEP_OUTPUT;
      80                 :            : 
      81                 :          0 :     case REG_DEP_CONTROL:
      82                 :          0 :       return DEP_CONTROL;
      83                 :            : 
      84                 :          0 :     default:
      85                 :          0 :       gcc_assert (dk == REG_DEP_ANTI);
      86                 :            :       return DEP_ANTI;
      87                 :            :     }
      88                 :            : }
      89                 :            : 
      90                 :            : /* Functions to operate with dependence information container - dep_t.  */
      91                 :            : 
      92                 :            : /* Init DEP with the arguments.  */
      93                 :            : void
      94                 :  393503000 : init_dep_1 (dep_t dep, rtx_insn *pro, rtx_insn *con, enum reg_note type, ds_t ds)
      95                 :            : {
      96                 :  393503000 :   DEP_PRO (dep) = pro;
      97                 :  393503000 :   DEP_CON (dep) = con;
      98                 :  393503000 :   DEP_TYPE (dep) = type;
      99                 :  393503000 :   DEP_STATUS (dep) = ds;
     100                 :  393503000 :   DEP_COST (dep) = UNKNOWN_DEP_COST;
     101                 :  393503000 :   DEP_NONREG (dep) = 0;
     102                 :  393503000 :   DEP_MULTIPLE (dep) = 0;
     103                 :  393503000 :   DEP_REPLACE (dep) = NULL;
     104                 :  393503000 :   dep->unused = 0;
     105                 :  393503000 : }
     106                 :            : 
     107                 :            : /* Init DEP with the arguments.
     108                 :            :    While most of the scheduler (including targets) only need the major type
     109                 :            :    of the dependency, it is convenient to hide full dep_status from them.  */
     110                 :            : void
     111                 :  378461000 : init_dep (dep_t dep, rtx_insn *pro, rtx_insn *con, enum reg_note kind)
     112                 :            : {
     113                 :  378461000 :   ds_t ds;
     114                 :            : 
     115                 :  378461000 :   if ((current_sched_info->flags & USE_DEPS_LIST))
     116                 :          0 :     ds = dk_to_ds (kind);
     117                 :            :   else
     118                 :            :     ds = 0;
     119                 :            : 
     120                 :  378461000 :   init_dep_1 (dep, pro, con, kind, ds);
     121                 :  378461000 : }
     122                 :            : 
     123                 :            : /* Make a copy of FROM in TO.  */
     124                 :            : static void
     125                 :  139230000 : copy_dep (dep_t to, dep_t from)
     126                 :            : {
     127                 :  139230000 :   memcpy (to, from, sizeof (*to));
     128                 :          0 : }
     129                 :            : 
     130                 :            : static void dump_ds (FILE *, ds_t);
     131                 :            : 
     132                 :            : /* Define flags for dump_dep ().  */
     133                 :            : 
     134                 :            : /* Dump producer of the dependence.  */
     135                 :            : #define DUMP_DEP_PRO (2)
     136                 :            : 
     137                 :            : /* Dump consumer of the dependence.  */
     138                 :            : #define DUMP_DEP_CON (4)
     139                 :            : 
     140                 :            : /* Dump type of the dependence.  */
     141                 :            : #define DUMP_DEP_TYPE (8)
     142                 :            : 
     143                 :            : /* Dump status of the dependence.  */
     144                 :            : #define DUMP_DEP_STATUS (16)
     145                 :            : 
     146                 :            : /* Dump all information about the dependence.  */
     147                 :            : #define DUMP_DEP_ALL (DUMP_DEP_PRO | DUMP_DEP_CON | DUMP_DEP_TYPE       \
     148                 :            :                       |DUMP_DEP_STATUS)
     149                 :            : 
     150                 :            : /* Dump DEP to DUMP.
     151                 :            :    FLAGS is a bit mask specifying what information about DEP needs
     152                 :            :    to be printed.
     153                 :            :    If FLAGS has the very first bit set, then dump all information about DEP
     154                 :            :    and propagate this bit into the callee dump functions.  */
     155                 :            : static void
     156                 :          0 : dump_dep (FILE *dump, dep_t dep, int flags)
     157                 :            : {
     158                 :          0 :   if (flags & 1)
     159                 :          0 :     flags |= DUMP_DEP_ALL;
     160                 :            : 
     161                 :          0 :   fprintf (dump, "<");
     162                 :            : 
     163                 :          0 :   if (flags & DUMP_DEP_PRO)
     164                 :          0 :     fprintf (dump, "%d; ", INSN_UID (DEP_PRO (dep)));
     165                 :            : 
     166                 :          0 :   if (flags & DUMP_DEP_CON)
     167                 :          0 :     fprintf (dump, "%d; ", INSN_UID (DEP_CON (dep)));
     168                 :            : 
     169                 :          0 :   if (flags & DUMP_DEP_TYPE)
     170                 :            :     {
     171                 :          0 :       char t;
     172                 :          0 :       enum reg_note type = DEP_TYPE (dep);
     173                 :            : 
     174                 :          0 :       switch (type)
     175                 :            :         {
     176                 :            :         case REG_DEP_TRUE:
     177                 :            :           t = 't';
     178                 :            :           break;
     179                 :            : 
     180                 :          0 :         case REG_DEP_OUTPUT:
     181                 :          0 :           t = 'o';
     182                 :          0 :           break;
     183                 :            : 
     184                 :          0 :         case REG_DEP_CONTROL:
     185                 :          0 :           t = 'c';
     186                 :          0 :           break;
     187                 :            : 
     188                 :          0 :         case REG_DEP_ANTI:
     189                 :          0 :           t = 'a';
     190                 :          0 :           break;
     191                 :            : 
     192                 :          0 :         default:
     193                 :          0 :           gcc_unreachable ();
     194                 :          0 :           break;
     195                 :            :         }
     196                 :            : 
     197                 :          0 :       fprintf (dump, "%c; ", t);
     198                 :            :     }
     199                 :            : 
     200                 :          0 :   if (flags & DUMP_DEP_STATUS)
     201                 :            :     {
     202                 :          0 :       if (current_sched_info->flags & USE_DEPS_LIST)
     203                 :          0 :         dump_ds (dump, DEP_STATUS (dep));
     204                 :            :     }
     205                 :            : 
     206                 :          0 :   fprintf (dump, ">");
     207                 :          0 : }
     208                 :            : 
     209                 :            : /* Default flags for dump_dep ().  */
     210                 :            : static int dump_dep_flags = (DUMP_DEP_PRO | DUMP_DEP_CON);
     211                 :            : 
     212                 :            : /* Dump all fields of DEP to STDERR.  */
     213                 :            : void
     214                 :          0 : sd_debug_dep (dep_t dep)
     215                 :            : {
     216                 :          0 :   dump_dep (stderr, dep, 1);
     217                 :          0 :   fprintf (stderr, "\n");
     218                 :          0 : }
     219                 :            : 
     220                 :            : /* Determine whether DEP is a dependency link of a non-debug insn on a
     221                 :            :    debug insn.  */
     222                 :            : 
     223                 :            : static inline bool
     224                 : 1094610000 : depl_on_debug_p (dep_link_t dep)
     225                 :            : {
     226                 : 1094610000 :   return (DEBUG_INSN_P (DEP_LINK_PRO (dep))
     227                 :  225751000 :           && !DEBUG_INSN_P (DEP_LINK_CON (dep)));
     228                 :            : }
     229                 :            : 
     230                 :            : /* Functions to operate with a single link from the dependencies lists -
     231                 :            :    dep_link_t.  */
     232                 :            : 
     233                 :            : /* Attach L to appear after link X whose &DEP_LINK_NEXT (X) is given by
     234                 :            :    PREV_NEXT_P.  */
     235                 :            : static void
     236                 :  547306000 : attach_dep_link (dep_link_t l, dep_link_t *prev_nextp)
     237                 :            : {
     238                 :  547306000 :   dep_link_t next = *prev_nextp;
     239                 :            : 
     240                 :  547306000 :   gcc_assert (DEP_LINK_PREV_NEXTP (l) == NULL
     241                 :            :               && DEP_LINK_NEXT (l) == NULL);
     242                 :            : 
     243                 :            :   /* Init node being inserted.  */
     244                 :  547306000 :   DEP_LINK_PREV_NEXTP (l) = prev_nextp;
     245                 :  547306000 :   DEP_LINK_NEXT (l) = next;
     246                 :            : 
     247                 :            :   /* Fix next node.  */
     248                 :  547306000 :   if (next != NULL)
     249                 :            :     {
     250                 :  317121000 :       gcc_assert (DEP_LINK_PREV_NEXTP (next) == prev_nextp);
     251                 :            : 
     252                 :  317121000 :       DEP_LINK_PREV_NEXTP (next) = &DEP_LINK_NEXT (l);
     253                 :            :     }
     254                 :            : 
     255                 :            :   /* Fix prev node.  */
     256                 :  547306000 :   *prev_nextp = l;
     257                 :  547306000 : }
     258                 :            : 
     259                 :            : /* Add dep_link LINK to deps_list L.  */
     260                 :            : static void
     261                 :  547306000 : add_to_deps_list (dep_link_t link, deps_list_t l)
     262                 :            : {
     263                 :  547306000 :   attach_dep_link (link, &DEPS_LIST_FIRST (l));
     264                 :            : 
     265                 :            :   /* Don't count debug deps.  */
     266                 :  547306000 :   if (!depl_on_debug_p (link))
     267                 :  536733000 :     ++DEPS_LIST_N_LINKS (l);
     268                 :  547306000 : }
     269                 :            : 
     270                 :            : /* Detach dep_link L from the list.  */
     271                 :            : static void
     272                 :  547306000 : detach_dep_link (dep_link_t l)
     273                 :            : {
     274                 :  547306000 :   dep_link_t *prev_nextp = DEP_LINK_PREV_NEXTP (l);
     275                 :  547306000 :   dep_link_t next = DEP_LINK_NEXT (l);
     276                 :            : 
     277                 :  547306000 :   *prev_nextp = next;
     278                 :            : 
     279                 :          0 :   if (next != NULL)
     280                 :  300968000 :     DEP_LINK_PREV_NEXTP (next) = prev_nextp;
     281                 :            : 
     282                 :  547306000 :   DEP_LINK_PREV_NEXTP (l) = NULL;
     283                 :  547306000 :   DEP_LINK_NEXT (l) = NULL;
     284                 :          0 : }
     285                 :            : 
     286                 :            : /* Remove link LINK from list LIST.  */
     287                 :            : static void
     288                 :  547306000 : remove_from_deps_list (dep_link_t link, deps_list_t list)
     289                 :            : {
     290                 :          0 :   detach_dep_link (link);
     291                 :            : 
     292                 :            :   /* Don't count debug deps.  */
     293                 :  547306000 :   if (!depl_on_debug_p (link))
     294                 :  536733000 :     --DEPS_LIST_N_LINKS (list);
     295                 :          0 : }
     296                 :            : 
     297                 :            : /* Move link LINK from list FROM to list TO.  */
     298                 :            : static void
     299                 :  268847000 : move_dep_link (dep_link_t link, deps_list_t from, deps_list_t to)
     300                 :            : {
     301                 :  268847000 :   remove_from_deps_list (link, from);
     302                 :  268847000 :   add_to_deps_list (link, to);
     303                 :  268847000 : }
     304                 :            : 
     305                 :            : /* Return true of LINK is not attached to any list.  */
     306                 :            : static bool
     307                 :  278459000 : dep_link_is_detached_p (dep_link_t link)
     308                 :            : {
     309                 :  278459000 :   return DEP_LINK_PREV_NEXTP (link) == NULL;
     310                 :            : }
     311                 :            : 
     312                 :            : /* Pool to hold all dependency nodes (dep_node_t).  */
     313                 :            : static object_allocator<_dep_node> *dn_pool;
     314                 :            : 
     315                 :            : /* Number of dep_nodes out there.  */
     316                 :            : static int dn_pool_diff = 0;
     317                 :            : 
     318                 :            : /* Create a dep_node.  */
     319                 :            : static dep_node_t
     320                 :  139230000 : create_dep_node (void)
     321                 :            : {
     322                 :  139230000 :   dep_node_t n = dn_pool->allocate ();
     323                 :  139230000 :   dep_link_t back = DEP_NODE_BACK (n);
     324                 :  139230000 :   dep_link_t forw = DEP_NODE_FORW (n);
     325                 :            : 
     326                 :  139230000 :   DEP_LINK_NODE (back) = n;
     327                 :  139230000 :   DEP_LINK_NEXT (back) = NULL;
     328                 :  139230000 :   DEP_LINK_PREV_NEXTP (back) = NULL;
     329                 :            : 
     330                 :  139230000 :   DEP_LINK_NODE (forw) = n;
     331                 :  139230000 :   DEP_LINK_NEXT (forw) = NULL;
     332                 :  139230000 :   DEP_LINK_PREV_NEXTP (forw) = NULL;
     333                 :            : 
     334                 :  139230000 :   ++dn_pool_diff;
     335                 :            : 
     336                 :  139230000 :   return n;
     337                 :            : }
     338                 :            : 
     339                 :            : /* Delete dep_node N.  N must not be connected to any deps_list.  */
     340                 :            : static void
     341                 :  139230000 : delete_dep_node (dep_node_t n)
     342                 :            : {
     343                 :  139230000 :   gcc_assert (dep_link_is_detached_p (DEP_NODE_BACK (n))
     344                 :            :               && dep_link_is_detached_p (DEP_NODE_FORW (n)));
     345                 :            : 
     346                 :  139230000 :   XDELETE (DEP_REPLACE (DEP_NODE_DEP (n)));
     347                 :            : 
     348                 :  139230000 :   --dn_pool_diff;
     349                 :            : 
     350                 :  139230000 :   dn_pool->remove (n);
     351                 :  139230000 : }
     352                 :            : 
     353                 :            : /* Pool to hold dependencies lists (deps_list_t).  */
     354                 :            : static object_allocator<_deps_list> *dl_pool;
     355                 :            : 
     356                 :            : /* Number of deps_lists out there.  */
     357                 :            : static int dl_pool_diff = 0;
     358                 :            : 
     359                 :            : /* Functions to operate with dependences lists - deps_list_t.  */
     360                 :            : 
     361                 :            : /* Return true if list L is empty.  */
     362                 :            : static bool
     363                 :  837727000 : deps_list_empty_p (deps_list_t l)
     364                 :            : {
     365                 :  837727000 :   return DEPS_LIST_N_LINKS (l) == 0;
     366                 :            : }
     367                 :            : 
     368                 :            : /* Create a new deps_list.  */
     369                 :            : static deps_list_t
     370                 :  334986000 : create_deps_list (void)
     371                 :            : {
     372                 :          0 :   deps_list_t l = dl_pool->allocate ();
     373                 :            : 
     374                 :  334986000 :   DEPS_LIST_FIRST (l) = NULL;
     375                 :  334986000 :   DEPS_LIST_N_LINKS (l) = 0;
     376                 :            : 
     377                 :  334986000 :   ++dl_pool_diff;
     378                 :  334986000 :   return l;
     379                 :            : }
     380                 :            : 
     381                 :            : /* Free deps_list L.  */
     382                 :            : static void
     383                 :  334986000 : free_deps_list (deps_list_t l)
     384                 :            : {
     385                 :  334986000 :   gcc_assert (deps_list_empty_p (l));
     386                 :            : 
     387                 :  334986000 :   --dl_pool_diff;
     388                 :            : 
     389                 :  334986000 :   dl_pool->remove (l);
     390                 :  334986000 : }
     391                 :            : 
     392                 :            : /* Return true if there is no dep_nodes and deps_lists out there.
     393                 :            :    After the region is scheduled all the dependency nodes and lists
     394                 :            :    should [generally] be returned to pool.  */
     395                 :            : bool
     396                 :    7169360 : deps_pools_are_empty_p (void)
     397                 :            : {
     398                 :    7169360 :   return dn_pool_diff == 0 && dl_pool_diff == 0;
     399                 :            : }
     400                 :            : 
     401                 :            : /* Remove all elements from L.  */
     402                 :            : static void
     403                 :   66997100 : clear_deps_list (deps_list_t l)
     404                 :            : {
     405                 :  201107000 :   do
     406                 :            :     {
     407                 :  201107000 :       dep_link_t link = DEPS_LIST_FIRST (l);
     408                 :            : 
     409                 :  201107000 :       if (link == NULL)
     410                 :            :         break;
     411                 :            : 
     412                 :  201107000 :       remove_from_deps_list (link, l);
     413                 :            :     }
     414                 :            :   while (1);
     415                 :   66997100 : }
     416                 :            : 
     417                 :            : /* Decide whether a dependency should be treated as a hard or a speculative
     418                 :            :    dependency.  */
     419                 :            : static bool
     420                 :  473407000 : dep_spec_p (dep_t dep)
     421                 :            : {
     422                 :  473407000 :   if (current_sched_info->flags & DO_SPECULATION)
     423                 :            :     {
     424                 :          0 :       if (DEP_STATUS (dep) & SPECULATIVE)
     425                 :            :         return true;
     426                 :            :     }
     427                 :  473407000 :   if (current_sched_info->flags & DO_PREDICATION)
     428                 :            :     {
     429                 :          0 :       if (DEP_TYPE (dep) == REG_DEP_CONTROL)
     430                 :            :         return true;
     431                 :            :     }
     432                 :  473407000 :   if (DEP_REPLACE (dep) != NULL)
     433                 :     648180 :     return true;
     434                 :            :   return false;
     435                 :            : }
     436                 :            : 
     437                 :            : static regset reg_pending_sets;
     438                 :            : static regset reg_pending_clobbers;
     439                 :            : static regset reg_pending_uses;
     440                 :            : static regset reg_pending_control_uses;
     441                 :            : static enum reg_pending_barrier_mode reg_pending_barrier;
     442                 :            : 
     443                 :            : /* Hard registers implicitly clobbered or used (or may be implicitly
     444                 :            :    clobbered or used) by the currently analyzed insn.  For example,
     445                 :            :    insn in its constraint has one register class.  Even if there is
     446                 :            :    currently no hard register in the insn, the particular hard
     447                 :            :    register will be in the insn after reload pass because the
     448                 :            :    constraint requires it.  */
     449                 :            : static HARD_REG_SET implicit_reg_pending_clobbers;
     450                 :            : static HARD_REG_SET implicit_reg_pending_uses;
     451                 :            : 
     452                 :            : /* To speed up the test for duplicate dependency links we keep a
     453                 :            :    record of dependencies created by add_dependence when the average
     454                 :            :    number of instructions in a basic block is very large.
     455                 :            : 
     456                 :            :    Studies have shown that there is typically around 5 instructions between
     457                 :            :    branches for typical C code.  So we can make a guess that the average
     458                 :            :    basic block is approximately 5 instructions long; we will choose 100X
     459                 :            :    the average size as a very large basic block.
     460                 :            : 
     461                 :            :    Each insn has associated bitmaps for its dependencies.  Each bitmap
     462                 :            :    has enough entries to represent a dependency on any other insn in
     463                 :            :    the insn chain.  All bitmap for true dependencies cache is
     464                 :            :    allocated then the rest two ones are also allocated.  */
     465                 :            : static bitmap true_dependency_cache = NULL;
     466                 :            : static bitmap output_dependency_cache = NULL;
     467                 :            : static bitmap anti_dependency_cache = NULL;
     468                 :            : static bitmap control_dependency_cache = NULL;
     469                 :            : static bitmap spec_dependency_cache = NULL;
     470                 :            : static int cache_size;
     471                 :            : 
     472                 :            : /* True if we should mark added dependencies as a non-register deps.  */
     473                 :            : static bool mark_as_hard;
     474                 :            : 
     475                 :            : static int deps_may_trap_p (const_rtx);
     476                 :            : static void add_dependence_1 (rtx_insn *, rtx_insn *, enum reg_note);
     477                 :            : static void add_dependence_list (rtx_insn *, rtx_insn_list *, int,
     478                 :            :                                  enum reg_note, bool);
     479                 :            : static void add_dependence_list_and_free (class deps_desc *, rtx_insn *,
     480                 :            :                                           rtx_insn_list **, int, enum reg_note,
     481                 :            :                                           bool);
     482                 :            : static void delete_all_dependences (rtx_insn *);
     483                 :            : static void chain_to_prev_insn (rtx_insn *);
     484                 :            : 
     485                 :            : static void flush_pending_lists (class deps_desc *, rtx_insn *, int, int);
     486                 :            : static void sched_analyze_1 (class deps_desc *, rtx, rtx_insn *);
     487                 :            : static void sched_analyze_2 (class deps_desc *, rtx, rtx_insn *);
     488                 :            : static void sched_analyze_insn (class deps_desc *, rtx, rtx_insn *);
     489                 :            : 
     490                 :            : static bool sched_has_condition_p (const rtx_insn *);
     491                 :            : static int conditions_mutex_p (const_rtx, const_rtx, bool, bool);
     492                 :            : 
     493                 :            : static enum DEPS_ADJUST_RESULT maybe_add_or_update_dep_1 (dep_t, bool,
     494                 :            :                                                           rtx, rtx);
     495                 :            : static enum DEPS_ADJUST_RESULT add_or_update_dep_1 (dep_t, bool, rtx, rtx);
     496                 :            : 
     497                 :            : static void check_dep (dep_t, bool);
     498                 :            : 
     499                 :            : 
     500                 :            : /* Return nonzero if a load of the memory reference MEM can cause a trap.  */
     501                 :            : 
     502                 :            : static int
     503                 :      14788 : deps_may_trap_p (const_rtx mem)
     504                 :            : {
     505                 :      14788 :   const_rtx addr = XEXP (mem, 0);
     506                 :            : 
     507                 :      14788 :   if (REG_P (addr) && REGNO (addr) >= FIRST_PSEUDO_REGISTER)
     508                 :            :     {
     509                 :          6 :       const_rtx t = get_reg_known_value (REGNO (addr));
     510                 :          6 :       if (t)
     511                 :          6 :         addr = t;
     512                 :            :     }
     513                 :      14788 :   return rtx_addr_can_trap_p (addr);
     514                 :            : }
     515                 :            : 
     516                 :            : 
     517                 :            : /* Find the condition under which INSN is executed.  If REV is not NULL,
     518                 :            :    it is set to TRUE when the returned comparison should be reversed
     519                 :            :    to get the actual condition.  */
     520                 :            : static rtx
     521                 :   40536300 : sched_get_condition_with_rev_uncached (const rtx_insn *insn, bool *rev)
     522                 :            : {
     523                 :   40536300 :   rtx pat = PATTERN (insn);
     524                 :   40536300 :   rtx src;
     525                 :            : 
     526                 :   40536300 :   if (rev)
     527                 :   40533600 :     *rev = false;
     528                 :            : 
     529                 :   40536300 :   if (GET_CODE (pat) == COND_EXEC)
     530                 :          0 :     return COND_EXEC_TEST (pat);
     531                 :            : 
     532                 :   40536300 :   if (!any_condjump_p (insn) || !onlyjump_p (insn))
     533                 :   37503600 :     return 0;
     534                 :            : 
     535                 :    3032780 :   src = SET_SRC (pc_set (insn));
     536                 :            : 
     537                 :    3032780 :   if (XEXP (src, 2) == pc_rtx)
     538                 :    3032780 :     return XEXP (src, 0);
     539                 :          0 :   else if (XEXP (src, 1) == pc_rtx)
     540                 :            :     {
     541                 :          0 :       rtx cond = XEXP (src, 0);
     542                 :          0 :       enum rtx_code revcode = reversed_comparison_code (cond, insn);
     543                 :            : 
     544                 :          0 :       if (revcode == UNKNOWN)
     545                 :            :         return 0;
     546                 :            : 
     547                 :          0 :       if (rev)
     548                 :          0 :         *rev = true;
     549                 :          0 :       return cond;
     550                 :            :     }
     551                 :            : 
     552                 :            :   return 0;
     553                 :            : }
     554                 :            : 
     555                 :            : /* Return the condition under which INSN does not execute (i.e.  the
     556                 :            :    not-taken condition for a conditional branch), or NULL if we cannot
     557                 :            :    find such a condition.  The caller should make a copy of the condition
     558                 :            :    before using it.  */
     559                 :            : rtx
     560                 :          0 : sched_get_reverse_condition_uncached (const rtx_insn *insn)
     561                 :            : {
     562                 :          0 :   bool rev;
     563                 :          0 :   rtx cond = sched_get_condition_with_rev_uncached (insn, &rev);
     564                 :          0 :   if (cond == NULL_RTX)
     565                 :            :     return cond;
     566                 :          0 :   if (!rev)
     567                 :            :     {
     568                 :          0 :       enum rtx_code revcode = reversed_comparison_code (cond, insn);
     569                 :          0 :       cond = gen_rtx_fmt_ee (revcode, GET_MODE (cond),
     570                 :            :                              XEXP (cond, 0),
     571                 :            :                              XEXP (cond, 1));
     572                 :            :     }
     573                 :            :   return cond;
     574                 :            : }
     575                 :            : 
     576                 :            : /* Caching variant of sched_get_condition_with_rev_uncached.
     577                 :            :    We only do actual work the first time we come here for an insn; the
     578                 :            :    results are cached in INSN_CACHED_COND and INSN_REVERSE_COND.  */
     579                 :            : static rtx
     580                 :  393245000 : sched_get_condition_with_rev (const rtx_insn *insn, bool *rev)
     581                 :            : {
     582                 :  393245000 :   bool tmp;
     583                 :            : 
     584                 :  393245000 :   if (INSN_LUID (insn) == 0)
     585                 :       5274 :     return sched_get_condition_with_rev_uncached (insn, rev);
     586                 :            : 
     587                 :  393240000 :   if (INSN_CACHED_COND (insn) == const_true_rtx)
     588                 :            :     return NULL_RTX;
     589                 :            : 
     590                 :   54181400 :   if (INSN_CACHED_COND (insn) != NULL_RTX)
     591                 :            :     {
     592                 :   13650400 :       if (rev)
     593                 :   10614700 :         *rev = INSN_REVERSE_COND (insn);
     594                 :   13650400 :       return INSN_CACHED_COND (insn);
     595                 :            :     }
     596                 :            : 
     597                 :   40531100 :   INSN_CACHED_COND (insn) = sched_get_condition_with_rev_uncached (insn, &tmp);
     598                 :   40531100 :   INSN_REVERSE_COND (insn) = tmp;
     599                 :            : 
     600                 :   40531100 :   if (INSN_CACHED_COND (insn) == NULL_RTX)
     601                 :            :     {
     602                 :   37498300 :       INSN_CACHED_COND (insn) = const_true_rtx;
     603                 :   37498300 :       return NULL_RTX;
     604                 :            :     }
     605                 :            : 
     606                 :    3032780 :   if (rev)
     607                 :          0 :     *rev = INSN_REVERSE_COND (insn);
     608                 :    3032780 :   return INSN_CACHED_COND (insn);
     609                 :            : }
     610                 :            : 
     611                 :            : /* True when we can find a condition under which INSN is executed.  */
     612                 :            : static bool
     613                 :   42106400 : sched_has_condition_p (const rtx_insn *insn)
     614                 :            : {
     615                 :          0 :   return !! sched_get_condition_with_rev (insn, NULL);
     616                 :            : }
     617                 :            : 
     618                 :            : 
     619                 :            : 
     620                 :            : /* Return nonzero if conditions COND1 and COND2 can never be both true.  */
     621                 :            : static int
     622                 :          5 : conditions_mutex_p (const_rtx cond1, const_rtx cond2, bool rev1, bool rev2)
     623                 :            : {
     624                 :          5 :   if (COMPARISON_P (cond1)
     625                 :          5 :       && COMPARISON_P (cond2)
     626                 :          5 :       && GET_CODE (cond1) ==
     627                 :            :           (rev1==rev2
     628                 :          5 :           ? reversed_comparison_code (cond2, NULL)
     629                 :            :           : GET_CODE (cond2))
     630                 :          0 :       && rtx_equal_p (XEXP (cond1, 0), XEXP (cond2, 0))
     631                 :          5 :       && XEXP (cond1, 1) == XEXP (cond2, 1))
     632                 :          0 :     return 1;
     633                 :            :   return 0;
     634                 :            : }
     635                 :            : 
     636                 :            : /* Return true if insn1 and insn2 can never depend on one another because
     637                 :            :    the conditions under which they are executed are mutually exclusive.  */
     638                 :            : bool
     639                 :  312118000 : sched_insns_conditions_mutex_p (const rtx_insn *insn1, const rtx_insn *insn2)
     640                 :            : {
     641                 :  312118000 :   rtx cond1, cond2;
     642                 :  312118000 :   bool rev1 = false, rev2 = false;
     643                 :            : 
     644                 :            :   /* df doesn't handle conditional lifetimes entirely correctly;
     645                 :            :      calls mess up the conditional lifetimes.  */
     646                 :  312118000 :   if (!CALL_P (insn1) && !CALL_P (insn2))
     647                 :            :     {
     648                 :  155928000 :       cond1 = sched_get_condition_with_rev (insn1, &rev1);
     649                 :  155928000 :       cond2 = sched_get_condition_with_rev (insn2, &rev2);
     650                 :  155928000 :       if (cond1 && cond2
     651                 :          5 :           && conditions_mutex_p (cond1, cond2, rev1, rev2)
     652                 :            :           /* Make sure first instruction doesn't affect condition of second
     653                 :            :              instruction if switched.  */
     654                 :          0 :           && !modified_in_p (cond1, insn2)
     655                 :            :           /* Make sure second instruction doesn't affect condition of first
     656                 :            :              instruction if switched.  */
     657                 :  155928000 :           && !modified_in_p (cond2, insn1))
     658                 :          0 :         return true;
     659                 :            :     }
     660                 :            :   return false;
     661                 :            : }
     662                 :            : 
     663                 :            : 
     664                 :            : /* Return true if INSN can potentially be speculated with type DS.  */
     665                 :            : bool
     666                 :          0 : sched_insn_is_legitimate_for_speculation_p (const rtx_insn *insn, ds_t ds)
     667                 :            : {
     668                 :          0 :   if (HAS_INTERNAL_DEP (insn))
     669                 :            :     return false;
     670                 :            : 
     671                 :          0 :   if (!NONJUMP_INSN_P (insn))
     672                 :            :     return false;
     673                 :            : 
     674                 :          0 :   if (SCHED_GROUP_P (insn))
     675                 :            :     return false;
     676                 :            : 
     677                 :          0 :   if (IS_SPECULATION_CHECK_P (CONST_CAST_RTX_INSN (insn)))
     678                 :            :     return false;
     679                 :            : 
     680                 :          0 :   if (side_effects_p (PATTERN (insn)))
     681                 :            :     return false;
     682                 :            : 
     683                 :          0 :   if (ds & BE_IN_SPEC)
     684                 :            :     /* The following instructions, which depend on a speculatively scheduled
     685                 :            :        instruction, cannot be speculatively scheduled along.  */
     686                 :            :     {
     687                 :          0 :       if (may_trap_or_fault_p (PATTERN (insn)))
     688                 :            :         /* If instruction might fault, it cannot be speculatively scheduled.
     689                 :            :            For control speculation it's obvious why and for data speculation
     690                 :            :            it's because the insn might get wrong input if speculation
     691                 :            :            wasn't successful.  */
     692                 :            :         return false;
     693                 :            : 
     694                 :          0 :       if ((ds & BE_IN_DATA)
     695                 :          0 :           && sched_has_condition_p (insn))
     696                 :            :         /* If this is a predicated instruction, then it cannot be
     697                 :            :            speculatively scheduled.  See PR35659.  */
     698                 :          0 :         return false;
     699                 :            :     }
     700                 :            : 
     701                 :            :   return true;
     702                 :            : }
     703                 :            : 
     704                 :            : /* Initialize LIST_PTR to point to one of the lists present in TYPES_PTR,
     705                 :            :    initialize RESOLVED_P_PTR with true if that list consists of resolved deps,
     706                 :            :    and remove the type of returned [through LIST_PTR] list from TYPES_PTR.
     707                 :            :    This function is used to switch sd_iterator to the next list.
     708                 :            :    !!! For internal use only.  Might consider moving it to sched-int.h.  */
     709                 :            : void
     710                 : 4143790000 : sd_next_list (const_rtx insn, sd_list_types_def *types_ptr,
     711                 :            :               deps_list_t *list_ptr, bool *resolved_p_ptr)
     712                 :            : {
     713                 : 4143790000 :   sd_list_types_def types = *types_ptr;
     714                 :            : 
     715                 : 4143790000 :   if (types & SD_LIST_HARD_BACK)
     716                 :            :     {
     717                 :  839549000 :       *list_ptr = INSN_HARD_BACK_DEPS (insn);
     718                 :  839549000 :       *resolved_p_ptr = false;
     719                 :  839549000 :       *types_ptr = types & ~SD_LIST_HARD_BACK;
     720                 :            :     }
     721                 : 3304240000 :   else if (types & SD_LIST_SPEC_BACK)
     722                 :            :     {
     723                 :  539156000 :       *list_ptr = INSN_SPEC_BACK_DEPS (insn);
     724                 :  539156000 :       *resolved_p_ptr = false;
     725                 :  539156000 :       *types_ptr = types & ~SD_LIST_SPEC_BACK;
     726                 :            :     }
     727                 : 2765080000 :   else if (types & SD_LIST_FORW)
     728                 :            :     {
     729                 : 1505070000 :       *list_ptr = INSN_FORW_DEPS (insn);
     730                 : 1505070000 :       *resolved_p_ptr = false;
     731                 : 1505070000 :       *types_ptr = types & ~SD_LIST_FORW;
     732                 :            :     }
     733                 : 1260020000 :   else if (types & SD_LIST_RES_BACK)
     734                 :            :     {
     735                 :  766383000 :       *list_ptr = INSN_RESOLVED_BACK_DEPS (insn);
     736                 :  766383000 :       *resolved_p_ptr = true;
     737                 :  766383000 :       *types_ptr = types & ~SD_LIST_RES_BACK;
     738                 :            :     }
     739                 :  493635000 :   else if (types & SD_LIST_RES_FORW)
     740                 :            :     {
     741                 :  493635000 :       *list_ptr = INSN_RESOLVED_FORW_DEPS (insn);
     742                 :  493635000 :       *resolved_p_ptr = true;
     743                 :  493635000 :       *types_ptr = types & ~SD_LIST_RES_FORW;
     744                 :            :     }
     745                 :            :   else
     746                 :            :     {
     747                 :          0 :       *list_ptr = NULL;
     748                 :          0 :       *resolved_p_ptr = false;
     749                 :          0 :       *types_ptr = SD_LIST_NONE;
     750                 :            :     }
     751                 : 4143790000 : }
     752                 :            : 
     753                 :            : /* Return the summary size of INSN's lists defined by LIST_TYPES.  */
     754                 :            : int
     755                 : 1898190000 : sd_lists_size (const_rtx insn, sd_list_types_def list_types)
     756                 :            : {
     757                 : 1898190000 :   int size = 0;
     758                 :            : 
     759                 : 4134680000 :   while (list_types != SD_LIST_NONE)
     760                 :            :     {
     761                 : 2236490000 :       deps_list_t list;
     762                 : 2236490000 :       bool resolved_p;
     763                 :            : 
     764                 : 2236490000 :       sd_next_list (insn, &list_types, &list, &resolved_p);
     765                 : 2236490000 :       if (list)
     766                 : 2236490000 :         size += DEPS_LIST_N_LINKS (list);
     767                 :            :     }
     768                 :            : 
     769                 : 1898190000 :   return size;
     770                 :            : }
     771                 :            : 
     772                 :            : /* Return true if INSN's lists defined by LIST_TYPES are all empty.  */
     773                 :            : 
     774                 :            : bool
     775                 :  435710000 : sd_lists_empty_p (const_rtx insn, sd_list_types_def list_types)
     776                 :            : {
     777                 :  647861000 :   while (list_types != SD_LIST_NONE)
     778                 :            :     {
     779                 :  502741000 :       deps_list_t list;
     780                 :  502741000 :       bool resolved_p;
     781                 :            : 
     782                 :  502741000 :       sd_next_list (insn, &list_types, &list, &resolved_p);
     783                 :  502741000 :       if (!deps_list_empty_p (list))
     784                 :  290590000 :         return false;
     785                 :            :     }
     786                 :            : 
     787                 :            :   return true;
     788                 :            : }
     789                 :            : 
     790                 :            : /* Initialize data for INSN.  */
     791                 :            : void
     792                 :   66997100 : sd_init_insn (rtx_insn *insn)
     793                 :            : {
     794                 :   66997100 :   INSN_HARD_BACK_DEPS (insn) = create_deps_list ();
     795                 :   66997100 :   INSN_SPEC_BACK_DEPS (insn) = create_deps_list ();
     796                 :   66997100 :   INSN_RESOLVED_BACK_DEPS (insn) = create_deps_list ();
     797                 :   66997100 :   INSN_FORW_DEPS (insn) = create_deps_list ();
     798                 :   66997100 :   INSN_RESOLVED_FORW_DEPS (insn) = create_deps_list ();
     799                 :            : 
     800                 :            :   /* ??? It would be nice to allocate dependency caches here.  */
     801                 :   66997100 : }
     802                 :            : 
     803                 :            : /* Free data for INSN.  */
     804                 :            : void
     805                 :   66997100 : sd_finish_insn (rtx_insn *insn)
     806                 :            : {
     807                 :            :   /* ??? It would be nice to deallocate dependency caches here.  */
     808                 :            : 
     809                 :   66997100 :   free_deps_list (INSN_HARD_BACK_DEPS (insn));
     810                 :   66997100 :   INSN_HARD_BACK_DEPS (insn) = NULL;
     811                 :            : 
     812                 :   66997100 :   free_deps_list (INSN_SPEC_BACK_DEPS (insn));
     813                 :   66997100 :   INSN_SPEC_BACK_DEPS (insn) = NULL;
     814                 :            : 
     815                 :   66997100 :   free_deps_list (INSN_RESOLVED_BACK_DEPS (insn));
     816                 :   66997100 :   INSN_RESOLVED_BACK_DEPS (insn) = NULL;
     817                 :            : 
     818                 :   66997100 :   free_deps_list (INSN_FORW_DEPS (insn));
     819                 :   66997100 :   INSN_FORW_DEPS (insn) = NULL;
     820                 :            : 
     821                 :   66997100 :   free_deps_list (INSN_RESOLVED_FORW_DEPS (insn));
     822                 :   66997100 :   INSN_RESOLVED_FORW_DEPS (insn) = NULL;
     823                 :   66997100 : }
     824                 :            : 
     825                 :            : /* Find a dependency between producer PRO and consumer CON.
     826                 :            :    Search through resolved dependency lists if RESOLVED_P is true.
     827                 :            :    If no such dependency is found return NULL,
     828                 :            :    otherwise return the dependency and initialize SD_IT_PTR [if it is nonnull]
     829                 :            :    with an iterator pointing to it.  */
     830                 :            : static dep_t
     831                 :  713252000 : sd_find_dep_between_no_cache (rtx pro, rtx con, bool resolved_p,
     832                 :            :                               sd_iterator_def *sd_it_ptr)
     833                 :            : {
     834                 :  713252000 :   sd_list_types_def pro_list_type;
     835                 :  713252000 :   sd_list_types_def con_list_type;
     836                 :  713252000 :   sd_iterator_def sd_it;
     837                 :  713252000 :   dep_t dep;
     838                 :  713252000 :   bool found_p = false;
     839                 :            : 
     840                 :  713252000 :   if (resolved_p)
     841                 :            :     {
     842                 :            :       pro_list_type = SD_LIST_RES_FORW;
     843                 :            :       con_list_type = SD_LIST_RES_BACK;
     844                 :            :     }
     845                 :            :   else
     846                 :            :     {
     847                 :  338303000 :       pro_list_type = SD_LIST_FORW;
     848                 :  338303000 :       con_list_type = SD_LIST_BACK;
     849                 :            :     }
     850                 :            : 
     851                 :            :   /* Walk through either back list of INSN or forw list of ELEM
     852                 :            :      depending on which one is shorter.  */
     853                 :  713252000 :   if (sd_lists_size (con, con_list_type) < sd_lists_size (pro, pro_list_type))
     854                 :            :     {
     855                 :            :       /* Find the dep_link with producer PRO in consumer's back_deps.  */
     856                 :  660001000 :       FOR_EACH_DEP (con, con_list_type, sd_it, dep)
     857                 :  399847000 :         if (DEP_PRO (dep) == pro)
     858                 :            :           {
     859                 :            :             found_p = true;
     860                 :            :             break;
     861                 :            :           }
     862                 :            :     }
     863                 :            :   else
     864                 :            :     {
     865                 :            :       /* Find the dep_link with consumer CON in producer's forw_deps.  */
     866                 :  766361000 :       FOR_EACH_DEP (pro, pro_list_type, sd_it, dep)
     867                 :  544355000 :         if (DEP_CON (dep) == con)
     868                 :            :           {
     869                 :            :             found_p = true;
     870                 :            :             break;
     871                 :            :           }
     872                 :            :     }
     873                 :            : 
     874                 :  713252000 :   if (found_p)
     875                 :            :     {
     876                 :  231091000 :       if (sd_it_ptr != NULL)
     877                 :  197108000 :         *sd_it_ptr = sd_it;
     878                 :            : 
     879                 :  231091000 :       return dep;
     880                 :            :     }
     881                 :            : 
     882                 :            :   return NULL;
     883                 :            : }
     884                 :            : 
     885                 :            : /* Find a dependency between producer PRO and consumer CON.
     886                 :            :    Use dependency [if available] to check if dependency is present at all.
     887                 :            :    Search through resolved dependency lists if RESOLVED_P is true.
     888                 :            :    If the dependency or NULL if none found.  */
     889                 :            : dep_t
     890                 :  378274000 : sd_find_dep_between (rtx pro, rtx con, bool resolved_p)
     891                 :            : {
     892                 :  378274000 :   if (true_dependency_cache != NULL)
     893                 :            :     /* Avoiding the list walk below can cut compile times dramatically
     894                 :            :        for some code.  */
     895                 :            :     {
     896                 :     604552 :       int elem_luid = INSN_LUID (pro);
     897                 :     604552 :       int insn_luid = INSN_LUID (con);
     898                 :            : 
     899                 :     604552 :       if (!bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid)
     900                 :     602595 :           && !bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid)
     901                 :     450473 :           && !bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid)
     902                 :    1026400 :           && !bitmap_bit_p (&control_dependency_cache[insn_luid], elem_luid))
     903                 :            :         return NULL;
     904                 :            :     }
     905                 :            : 
     906                 :  377852000 :   return sd_find_dep_between_no_cache (pro, con, resolved_p, NULL);
     907                 :            : }
     908                 :            : 
     909                 :            : /* Add or update  a dependence described by DEP.
     910                 :            :    MEM1 and MEM2, if non-null, correspond to memory locations in case of
     911                 :            :    data speculation.
     912                 :            : 
     913                 :            :    The function returns a value indicating if an old entry has been changed
     914                 :            :    or a new entry has been added to insn's backward deps.
     915                 :            : 
     916                 :            :    This function merely checks if producer and consumer is the same insn
     917                 :            :    and doesn't create a dep in this case.  Actual manipulation of
     918                 :            :    dependence data structures is performed in add_or_update_dep_1.  */
     919                 :            : static enum DEPS_ADJUST_RESULT
     920                 :  393478000 : maybe_add_or_update_dep_1 (dep_t dep, bool resolved_p, rtx mem1, rtx mem2)
     921                 :            : {
     922                 :  393478000 :   rtx_insn *elem = DEP_PRO (dep);
     923                 :  393478000 :   rtx_insn *insn = DEP_CON (dep);
     924                 :            : 
     925                 :  393478000 :   gcc_assert (INSN_P (insn) && INSN_P (elem));
     926                 :            : 
     927                 :            :   /* Don't depend an insn on itself.  */
     928                 :  393478000 :   if (insn == elem)
     929                 :            :     {
     930                 :   57140400 :       if (sched_deps_info->generate_spec_deps)
     931                 :            :         /* INSN has an internal dependence, which we can't overcome.  */
     932                 :          0 :         HAS_INTERNAL_DEP (insn) = 1;
     933                 :            : 
     934                 :   57140400 :       return DEP_NODEP;
     935                 :            :     }
     936                 :            : 
     937                 :  336338000 :   return add_or_update_dep_1 (dep, resolved_p, mem1, mem2);
     938                 :            : }
     939                 :            : 
     940                 :            : /* Ask dependency caches what needs to be done for dependence DEP.
     941                 :            :    Return DEP_CREATED if new dependence should be created and there is no
     942                 :            :    need to try to find one searching the dependencies lists.
     943                 :            :    Return DEP_PRESENT if there already is a dependence described by DEP and
     944                 :            :    hence nothing is to be done.
     945                 :            :    Return DEP_CHANGED if there already is a dependence, but it should be
     946                 :            :    updated to incorporate additional information from DEP.  */
     947                 :            : static enum DEPS_ADJUST_RESULT
     948                 :    3128750 : ask_dependency_caches (dep_t dep)
     949                 :            : {
     950                 :    3128750 :   int elem_luid = INSN_LUID (DEP_PRO (dep));
     951                 :    3128750 :   int insn_luid = INSN_LUID (DEP_CON (dep));
     952                 :            : 
     953                 :    3128750 :   gcc_assert (true_dependency_cache != NULL
     954                 :            :               && output_dependency_cache != NULL
     955                 :            :               && anti_dependency_cache != NULL
     956                 :            :               && control_dependency_cache != NULL);
     957                 :            : 
     958                 :    3128750 :   if (!(current_sched_info->flags & USE_DEPS_LIST))
     959                 :            :     {
     960                 :    3128750 :       enum reg_note present_dep_type;
     961                 :            : 
     962                 :    3128750 :       if (bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid))
     963                 :            :         present_dep_type = REG_DEP_TRUE;
     964                 :    2969940 :       else if (bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid))
     965                 :            :         present_dep_type = REG_DEP_OUTPUT;
     966                 :    1072280 :       else if (bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid))
     967                 :            :         present_dep_type = REG_DEP_ANTI;
     968                 :     938565 :       else if (bitmap_bit_p (&control_dependency_cache[insn_luid], elem_luid))
     969                 :            :         present_dep_type = REG_DEP_CONTROL;
     970                 :            :       else
     971                 :            :         /* There is no existing dep so it should be created.  */
     972                 :            :         return DEP_CREATED;
     973                 :            : 
     974                 :    2190190 :       if ((int) DEP_TYPE (dep) >= (int) present_dep_type)
     975                 :            :         /* DEP does not add anything to the existing dependence.  */
     976                 :    2160230 :         return DEP_PRESENT;
     977                 :            :     }
     978                 :            :   else
     979                 :            :     {
     980                 :          0 :       ds_t present_dep_types = 0;
     981                 :            : 
     982                 :          0 :       if (bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid))
     983                 :          0 :         present_dep_types |= DEP_TRUE;
     984                 :          0 :       if (bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid))
     985                 :          0 :         present_dep_types |= DEP_OUTPUT;
     986                 :          0 :       if (bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid))
     987                 :          0 :         present_dep_types |= DEP_ANTI;
     988                 :          0 :       if (bitmap_bit_p (&control_dependency_cache[insn_luid], elem_luid))
     989                 :          0 :         present_dep_types |= DEP_CONTROL;
     990                 :            : 
     991                 :          0 :       if (present_dep_types == 0)
     992                 :            :         /* There is no existing dep so it should be created.  */
     993                 :            :         return DEP_CREATED;
     994                 :            : 
     995                 :          0 :       if (!(current_sched_info->flags & DO_SPECULATION)
     996                 :          0 :           || !bitmap_bit_p (&spec_dependency_cache[insn_luid], elem_luid))
     997                 :            :         {
     998                 :          0 :           if ((present_dep_types | (DEP_STATUS (dep) & DEP_TYPES))
     999                 :            :               == present_dep_types)
    1000                 :            :             /* DEP does not add anything to the existing dependence.  */
    1001                 :          0 :             return DEP_PRESENT;
    1002                 :            :         }
    1003                 :            :       else
    1004                 :            :         {
    1005                 :            :           /* Only true dependencies can be data speculative and
    1006                 :            :              only anti dependencies can be control speculative.  */
    1007                 :          0 :           gcc_assert ((present_dep_types & (DEP_TRUE | DEP_ANTI))
    1008                 :            :                       == present_dep_types);
    1009                 :            : 
    1010                 :            :           /* if (DEP is SPECULATIVE) then
    1011                 :            :              ..we should update DEP_STATUS
    1012                 :            :              else
    1013                 :            :              ..we should reset existing dep to non-speculative.  */
    1014                 :            :         }
    1015                 :            :     }
    1016                 :            : 
    1017                 :            :   return DEP_CHANGED;
    1018                 :            : }
    1019                 :            : 
    1020                 :            : /* Set dependency caches according to DEP.  */
    1021                 :            : static void
    1022                 :     968523 : set_dependency_caches (dep_t dep)
    1023                 :            : {
    1024                 :     968523 :   int elem_luid = INSN_LUID (DEP_PRO (dep));
    1025                 :     968523 :   int insn_luid = INSN_LUID (DEP_CON (dep));
    1026                 :            : 
    1027                 :     968523 :   if (!(current_sched_info->flags & USE_DEPS_LIST))
    1028                 :            :     {
    1029                 :     968523 :       switch (DEP_TYPE (dep))
    1030                 :            :         {
    1031                 :     142552 :         case REG_DEP_TRUE:
    1032                 :     142552 :           bitmap_set_bit (&true_dependency_cache[insn_luid], elem_luid);
    1033                 :     142552 :           break;
    1034                 :            : 
    1035                 :     339990 :         case REG_DEP_OUTPUT:
    1036                 :     339990 :           bitmap_set_bit (&output_dependency_cache[insn_luid], elem_luid);
    1037                 :     339990 :           break;
    1038                 :            : 
    1039                 :     485981 :         case REG_DEP_ANTI:
    1040                 :     485981 :           bitmap_set_bit (&anti_dependency_cache[insn_luid], elem_luid);
    1041                 :     485981 :           break;
    1042                 :            : 
    1043                 :          0 :         case REG_DEP_CONTROL:
    1044                 :          0 :           bitmap_set_bit (&control_dependency_cache[insn_luid], elem_luid);
    1045                 :          0 :           break;
    1046                 :            : 
    1047                 :          0 :         default:
    1048                 :          0 :           gcc_unreachable ();
    1049                 :            :         }
    1050                 :            :     }
    1051                 :            :   else
    1052                 :            :     {
    1053                 :          0 :       ds_t ds = DEP_STATUS (dep);
    1054                 :            : 
    1055                 :          0 :       if (ds & DEP_TRUE)
    1056                 :          0 :         bitmap_set_bit (&true_dependency_cache[insn_luid], elem_luid);
    1057                 :          0 :       if (ds & DEP_OUTPUT)
    1058                 :          0 :         bitmap_set_bit (&output_dependency_cache[insn_luid], elem_luid);
    1059                 :          0 :       if (ds & DEP_ANTI)
    1060                 :          0 :         bitmap_set_bit (&anti_dependency_cache[insn_luid], elem_luid);
    1061                 :          0 :       if (ds & DEP_CONTROL)
    1062                 :          0 :         bitmap_set_bit (&control_dependency_cache[insn_luid], elem_luid);
    1063                 :            : 
    1064                 :          0 :       if (ds & SPECULATIVE)
    1065                 :            :         {
    1066                 :          0 :           gcc_assert (current_sched_info->flags & DO_SPECULATION);
    1067                 :          0 :           bitmap_set_bit (&spec_dependency_cache[insn_luid], elem_luid);
    1068                 :            :         }
    1069                 :            :     }
    1070                 :     968523 : }
    1071                 :            : 
    1072                 :            : /* Type of dependence DEP have changed from OLD_TYPE.  Update dependency
    1073                 :            :    caches accordingly.  */
    1074                 :            : static void
    1075                 :      29958 : update_dependency_caches (dep_t dep, enum reg_note old_type)
    1076                 :            : {
    1077                 :      29958 :   int elem_luid = INSN_LUID (DEP_PRO (dep));
    1078                 :      29958 :   int insn_luid = INSN_LUID (DEP_CON (dep));
    1079                 :            : 
    1080                 :            :   /* Clear corresponding cache entry because type of the link
    1081                 :            :      may have changed.  Keep them if we use_deps_list.  */
    1082                 :      29958 :   if (!(current_sched_info->flags & USE_DEPS_LIST))
    1083                 :            :     {
    1084                 :      29958 :       switch (old_type)
    1085                 :            :         {
    1086                 :       3811 :         case REG_DEP_OUTPUT:
    1087                 :       3811 :           bitmap_clear_bit (&output_dependency_cache[insn_luid], elem_luid);
    1088                 :       3811 :           break;
    1089                 :            : 
    1090                 :      26147 :         case REG_DEP_ANTI:
    1091                 :      26147 :           bitmap_clear_bit (&anti_dependency_cache[insn_luid], elem_luid);
    1092                 :      26147 :           break;
    1093                 :            : 
    1094                 :          0 :         case REG_DEP_CONTROL:
    1095                 :          0 :           bitmap_clear_bit (&control_dependency_cache[insn_luid], elem_luid);
    1096                 :          0 :           break;
    1097                 :            : 
    1098                 :          0 :         default:
    1099                 :          0 :           gcc_unreachable ();
    1100                 :            :         }
    1101                 :            :     }
    1102                 :            : 
    1103                 :      29958 :   set_dependency_caches (dep);
    1104                 :      29958 : }
    1105                 :            : 
    1106                 :            : /* Convert a dependence pointed to by SD_IT to be non-speculative.  */
    1107                 :            : static void
    1108                 :          0 : change_spec_dep_to_hard (sd_iterator_def sd_it)
    1109                 :            : {
    1110                 :          0 :   dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
    1111                 :          0 :   dep_link_t link = DEP_NODE_BACK (node);
    1112                 :          0 :   dep_t dep = DEP_NODE_DEP (node);
    1113                 :          0 :   rtx_insn *elem = DEP_PRO (dep);
    1114                 :          0 :   rtx_insn *insn = DEP_CON (dep);
    1115                 :            : 
    1116                 :          0 :   move_dep_link (link, INSN_SPEC_BACK_DEPS (insn), INSN_HARD_BACK_DEPS (insn));
    1117                 :            : 
    1118                 :          0 :   DEP_STATUS (dep) &= ~SPECULATIVE;
    1119                 :            : 
    1120                 :          0 :   if (true_dependency_cache != NULL)
    1121                 :            :     /* Clear the cache entry.  */
    1122                 :          0 :     bitmap_clear_bit (&spec_dependency_cache[INSN_LUID (insn)],
    1123                 :          0 :                       INSN_LUID (elem));
    1124                 :          0 : }
    1125                 :            : 
    1126                 :            : /* Update DEP to incorporate information from NEW_DEP.
    1127                 :            :    SD_IT points to DEP in case it should be moved to another list.
    1128                 :            :    MEM1 and MEM2, if nonnull, correspond to memory locations in case if
    1129                 :            :    data-speculative dependence should be updated.  */
    1130                 :            : static enum DEPS_ADJUST_RESULT
    1131                 :  194948000 : update_dep (dep_t dep, dep_t new_dep,
    1132                 :            :             sd_iterator_def sd_it ATTRIBUTE_UNUSED,
    1133                 :            :             rtx mem1 ATTRIBUTE_UNUSED,
    1134                 :            :             rtx mem2 ATTRIBUTE_UNUSED)
    1135                 :            : {
    1136                 :  194948000 :   enum DEPS_ADJUST_RESULT res = DEP_PRESENT;
    1137                 :  194948000 :   enum reg_note old_type = DEP_TYPE (dep);
    1138                 :  194948000 :   bool was_spec = dep_spec_p (dep);
    1139                 :            : 
    1140                 :  194948000 :   DEP_NONREG (dep) |= DEP_NONREG (new_dep);
    1141                 :  194948000 :   DEP_MULTIPLE (dep) = 1;
    1142                 :            : 
    1143                 :            :   /* If this is a more restrictive type of dependence than the
    1144                 :            :      existing one, then change the existing dependence to this
    1145                 :            :      type.  */
    1146                 :  194948000 :   if ((int) DEP_TYPE (new_dep) < (int) old_type)
    1147                 :            :     {
    1148                 :   10011200 :       DEP_TYPE (dep) = DEP_TYPE (new_dep);
    1149                 :   10011200 :       res = DEP_CHANGED;
    1150                 :            :     }
    1151                 :            : 
    1152                 :  194948000 :   if (current_sched_info->flags & USE_DEPS_LIST)
    1153                 :            :     /* Update DEP_STATUS.  */
    1154                 :            :     {
    1155                 :          0 :       ds_t dep_status = DEP_STATUS (dep);
    1156                 :          0 :       ds_t ds = DEP_STATUS (new_dep);
    1157                 :          0 :       ds_t new_status = ds | dep_status;
    1158                 :            : 
    1159                 :          0 :       if (new_status & SPECULATIVE)
    1160                 :            :         {
    1161                 :            :           /* Either existing dep or a dep we're adding or both are
    1162                 :            :              speculative.  */
    1163                 :          0 :           if (!(ds & SPECULATIVE)
    1164                 :          0 :               || !(dep_status & SPECULATIVE))
    1165                 :            :             /* The new dep can't be speculative.  */
    1166                 :          0 :             new_status &= ~SPECULATIVE;
    1167                 :            :           else
    1168                 :            :             {
    1169                 :            :               /* Both are speculative.  Merge probabilities.  */
    1170                 :          0 :               if (mem1 != NULL)
    1171                 :            :                 {
    1172                 :          0 :                   dw_t dw;
    1173                 :            : 
    1174                 :          0 :                   dw = estimate_dep_weak (mem1, mem2);
    1175                 :          0 :                   ds = set_dep_weak (ds, BEGIN_DATA, dw);
    1176                 :            :                 }
    1177                 :            : 
    1178                 :          0 :               new_status = ds_merge (dep_status, ds);
    1179                 :            :             }
    1180                 :            :         }
    1181                 :            : 
    1182                 :          0 :       ds = new_status;
    1183                 :            : 
    1184                 :          0 :       if (dep_status != ds)
    1185                 :            :         {
    1186                 :          0 :           DEP_STATUS (dep) = ds;
    1187                 :          0 :           res = DEP_CHANGED;
    1188                 :            :         }
    1189                 :            :     }
    1190                 :            : 
    1191                 :  194948000 :   if (was_spec && !dep_spec_p (dep))
    1192                 :            :     /* The old dep was speculative, but now it isn't.  */
    1193                 :          0 :     change_spec_dep_to_hard (sd_it);
    1194                 :            : 
    1195                 :  194948000 :   if (true_dependency_cache != NULL
    1196                 :      29958 :       && res == DEP_CHANGED)
    1197                 :      29958 :     update_dependency_caches (dep, old_type);
    1198                 :            : 
    1199                 :  194948000 :   return res;
    1200                 :            : }
    1201                 :            : 
    1202                 :            : /* Add or update  a dependence described by DEP.
    1203                 :            :    MEM1 and MEM2, if non-null, correspond to memory locations in case of
    1204                 :            :    data speculation.
    1205                 :            : 
    1206                 :            :    The function returns a value indicating if an old entry has been changed
    1207                 :            :    or a new entry has been added to insn's backward deps or nothing has
    1208                 :            :    been updated at all.  */
    1209                 :            : static enum DEPS_ADJUST_RESULT
    1210                 :  336338000 : add_or_update_dep_1 (dep_t new_dep, bool resolved_p,
    1211                 :            :                      rtx mem1 ATTRIBUTE_UNUSED, rtx mem2 ATTRIBUTE_UNUSED)
    1212                 :            : {
    1213                 :  336338000 :   bool maybe_present_p = true;
    1214                 :  336338000 :   bool present_p = false;
    1215                 :            : 
    1216                 :  336338000 :   gcc_assert (INSN_P (DEP_PRO (new_dep)) && INSN_P (DEP_CON (new_dep))
    1217                 :            :               && DEP_PRO (new_dep) != DEP_CON (new_dep));
    1218                 :            : 
    1219                 :  336338000 :   if (flag_checking)
    1220                 :  336338000 :     check_dep (new_dep, mem1 != NULL);
    1221                 :            : 
    1222                 :  336338000 :   if (true_dependency_cache != NULL)
    1223                 :            :     {
    1224                 :    3128750 :       switch (ask_dependency_caches (new_dep))
    1225                 :            :         {
    1226                 :    2160230 :         case DEP_PRESENT:
    1227                 :    2160230 :           dep_t present_dep;
    1228                 :    2160230 :           sd_iterator_def sd_it;
    1229                 :            :       
    1230                 :    4320460 :           present_dep = sd_find_dep_between_no_cache (DEP_PRO (new_dep),
    1231                 :    2160230 :                                                       DEP_CON (new_dep),
    1232                 :            :                                                       resolved_p, &sd_it);
    1233                 :    2160230 :           DEP_MULTIPLE (present_dep) = 1;
    1234                 :    2160230 :           return DEP_PRESENT;
    1235                 :            : 
    1236                 :            :         case DEP_CHANGED:
    1237                 :            :           maybe_present_p = true;
    1238                 :            :           present_p = true;
    1239                 :     968523 :           break;
    1240                 :            : 
    1241                 :     938565 :         case DEP_CREATED:
    1242                 :     938565 :           maybe_present_p = false;
    1243                 :     938565 :           present_p = false;
    1244                 :     938565 :           break;
    1245                 :            : 
    1246                 :          0 :         default:
    1247                 :          0 :           gcc_unreachable ();
    1248                 :    2160230 :           break;
    1249                 :            :         }
    1250                 :            :     }
    1251                 :            : 
    1252                 :            :   /* Check that we don't already have this dependence.  */
    1253                 :     968523 :   if (maybe_present_p)
    1254                 :            :     {
    1255                 :  333239000 :       dep_t present_dep;
    1256                 :  333239000 :       sd_iterator_def sd_it;
    1257                 :            : 
    1258                 :  333239000 :       gcc_assert (true_dependency_cache == NULL || present_p);
    1259                 :            : 
    1260                 :  666478000 :       present_dep = sd_find_dep_between_no_cache (DEP_PRO (new_dep),
    1261                 :  333239000 :                                                   DEP_CON (new_dep),
    1262                 :            :                                                   resolved_p, &sd_it);
    1263                 :            : 
    1264                 :  333239000 :       if (present_dep != NULL)
    1265                 :            :         /* We found an existing dependency between ELEM and INSN.  */
    1266                 :  194948000 :         return update_dep (present_dep, new_dep, sd_it, mem1, mem2);
    1267                 :            :       else
    1268                 :            :         /* We didn't find a dep, it shouldn't present in the cache.  */
    1269                 :  138291000 :         gcc_assert (!present_p);
    1270                 :            :     }
    1271                 :            : 
    1272                 :            :   /* Might want to check one level of transitivity to save conses.
    1273                 :            :      This check should be done in maybe_add_or_update_dep_1.
    1274                 :            :      Since we made it to add_or_update_dep_1, we must create
    1275                 :            :      (or update) a link.  */
    1276                 :            : 
    1277                 :  139230000 :   if (mem1 != NULL_RTX)
    1278                 :            :     {
    1279                 :          0 :       gcc_assert (sched_deps_info->generate_spec_deps);
    1280                 :          0 :       DEP_STATUS (new_dep) = set_dep_weak (DEP_STATUS (new_dep), BEGIN_DATA,
    1281                 :            :                                            estimate_dep_weak (mem1, mem2));
    1282                 :            :     }
    1283                 :            : 
    1284                 :  139230000 :   sd_add_dep (new_dep, resolved_p);
    1285                 :            : 
    1286                 :  139230000 :   return DEP_CREATED;
    1287                 :            : }
    1288                 :            : 
    1289                 :            : /* Initialize BACK_LIST_PTR with consumer's backward list and
    1290                 :            :    FORW_LIST_PTR with producer's forward list.  If RESOLVED_P is true
    1291                 :            :    initialize with lists that hold resolved deps.  */
    1292                 :            : static void
    1293                 :  278459000 : get_back_and_forw_lists (dep_t dep, bool resolved_p,
    1294                 :            :                          deps_list_t *back_list_ptr,
    1295                 :            :                          deps_list_t *forw_list_ptr)
    1296                 :            : {
    1297                 :  278459000 :   rtx_insn *con = DEP_CON (dep);
    1298                 :            : 
    1299                 :  278459000 :   if (!resolved_p)
    1300                 :            :     {
    1301                 :  144360000 :       if (dep_spec_p (dep))
    1302                 :          0 :         *back_list_ptr = INSN_SPEC_BACK_DEPS (con);
    1303                 :            :       else
    1304                 :  144360000 :         *back_list_ptr = INSN_HARD_BACK_DEPS (con);
    1305                 :            : 
    1306                 :  144360000 :       *forw_list_ptr = INSN_FORW_DEPS (DEP_PRO (dep));
    1307                 :            :     }
    1308                 :            :   else
    1309                 :            :     {
    1310                 :  134099000 :       *back_list_ptr = INSN_RESOLVED_BACK_DEPS (con);
    1311                 :  134099000 :       *forw_list_ptr = INSN_RESOLVED_FORW_DEPS (DEP_PRO (dep));
    1312                 :            :     }
    1313                 :  278459000 : }
    1314                 :            : 
    1315                 :            : /* Add dependence described by DEP.
    1316                 :            :    If RESOLVED_P is true treat the dependence as a resolved one.  */
    1317                 :            : void
    1318                 :  139230000 : sd_add_dep (dep_t dep, bool resolved_p)
    1319                 :            : {
    1320                 :  139230000 :   dep_node_t n = create_dep_node ();
    1321                 :  139230000 :   deps_list_t con_back_deps;
    1322                 :  139230000 :   deps_list_t pro_forw_deps;
    1323                 :  139230000 :   rtx_insn *elem = DEP_PRO (dep);
    1324                 :  139230000 :   rtx_insn *insn = DEP_CON (dep);
    1325                 :            : 
    1326                 :  139230000 :   gcc_assert (INSN_P (insn) && INSN_P (elem) && insn != elem);
    1327                 :            : 
    1328                 :  139230000 :   if ((current_sched_info->flags & DO_SPECULATION) == 0
    1329                 :  139230000 :       || !sched_insn_is_legitimate_for_speculation_p (insn, DEP_STATUS (dep)))
    1330                 :  139230000 :     DEP_STATUS (dep) &= ~SPECULATIVE;
    1331                 :            : 
    1332                 :  139230000 :   copy_dep (DEP_NODE_DEP (n), dep);
    1333                 :            : 
    1334                 :  139230000 :   get_back_and_forw_lists (dep, resolved_p, &con_back_deps, &pro_forw_deps);
    1335                 :            : 
    1336                 :  139230000 :   add_to_deps_list (DEP_NODE_BACK (n), con_back_deps);
    1337                 :            : 
    1338                 :  139230000 :   if (flag_checking)
    1339                 :  139230000 :     check_dep (dep, false);
    1340                 :            : 
    1341                 :  139230000 :   add_to_deps_list (DEP_NODE_FORW (n), pro_forw_deps);
    1342                 :            : 
    1343                 :            :   /* If we are adding a dependency to INSN's LOG_LINKs, then note that
    1344                 :            :      in the bitmap caches of dependency information.  */
    1345                 :  139230000 :   if (true_dependency_cache != NULL)
    1346                 :     938565 :     set_dependency_caches (dep);
    1347                 :  139230000 : }
    1348                 :            : 
    1349                 :            : /* Add or update backward dependence between INSN and ELEM
    1350                 :            :    with given type DEP_TYPE and dep_status DS.
    1351                 :            :    This function is a convenience wrapper.  */
    1352                 :            : enum DEPS_ADJUST_RESULT
    1353                 :          0 : sd_add_or_update_dep (dep_t dep, bool resolved_p)
    1354                 :            : {
    1355                 :          0 :   return add_or_update_dep_1 (dep, resolved_p, NULL_RTX, NULL_RTX);
    1356                 :            : }
    1357                 :            : 
    1358                 :            : /* Resolved dependence pointed to by SD_IT.
    1359                 :            :    SD_IT will advance to the next element.  */
    1360                 :            : void
    1361                 :  134099000 : sd_resolve_dep (sd_iterator_def sd_it)
    1362                 :            : {
    1363                 :  134099000 :   dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
    1364                 :  134099000 :   dep_t dep = DEP_NODE_DEP (node);
    1365                 :  134099000 :   rtx_insn *pro = DEP_PRO (dep);
    1366                 :  134099000 :   rtx_insn *con = DEP_CON (dep);
    1367                 :            : 
    1368                 :  134099000 :   if (dep_spec_p (dep))
    1369                 :     648180 :     move_dep_link (DEP_NODE_BACK (node), INSN_SPEC_BACK_DEPS (con),
    1370                 :     648180 :                    INSN_RESOLVED_BACK_DEPS (con));
    1371                 :            :   else
    1372                 :  133451000 :     move_dep_link (DEP_NODE_BACK (node), INSN_HARD_BACK_DEPS (con),
    1373                 :  133451000 :                    INSN_RESOLVED_BACK_DEPS (con));
    1374                 :            : 
    1375                 :  134099000 :   move_dep_link (DEP_NODE_FORW (node), INSN_FORW_DEPS (pro),
    1376                 :  134099000 :                  INSN_RESOLVED_FORW_DEPS (pro));
    1377                 :  134099000 : }
    1378                 :            : 
    1379                 :            : /* Perform the inverse operation of sd_resolve_dep.  Restore the dependence
    1380                 :            :    pointed to by SD_IT to unresolved state.  */
    1381                 :            : void
    1382                 :          0 : sd_unresolve_dep (sd_iterator_def sd_it)
    1383                 :            : {
    1384                 :          0 :   dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
    1385                 :          0 :   dep_t dep = DEP_NODE_DEP (node);
    1386                 :          0 :   rtx_insn *pro = DEP_PRO (dep);
    1387                 :          0 :   rtx_insn *con = DEP_CON (dep);
    1388                 :            : 
    1389                 :          0 :   if (dep_spec_p (dep))
    1390                 :          0 :     move_dep_link (DEP_NODE_BACK (node), INSN_RESOLVED_BACK_DEPS (con),
    1391                 :          0 :                    INSN_SPEC_BACK_DEPS (con));
    1392                 :            :   else
    1393                 :          0 :     move_dep_link (DEP_NODE_BACK (node), INSN_RESOLVED_BACK_DEPS (con),
    1394                 :          0 :                    INSN_HARD_BACK_DEPS (con));
    1395                 :            : 
    1396                 :          0 :   move_dep_link (DEP_NODE_FORW (node), INSN_RESOLVED_FORW_DEPS (pro),
    1397                 :          0 :                  INSN_FORW_DEPS (pro));
    1398                 :          0 : }
    1399                 :            : 
    1400                 :            : /* Make TO depend on all the FROM's producers.
    1401                 :            :    If RESOLVED_P is true add dependencies to the resolved lists.  */
    1402                 :            : void
    1403                 :          0 : sd_copy_back_deps (rtx_insn *to, rtx_insn *from, bool resolved_p)
    1404                 :            : {
    1405                 :          0 :   sd_list_types_def list_type;
    1406                 :          0 :   sd_iterator_def sd_it;
    1407                 :          0 :   dep_t dep;
    1408                 :            : 
    1409                 :          0 :   list_type = resolved_p ? SD_LIST_RES_BACK : SD_LIST_BACK;
    1410                 :            : 
    1411                 :          0 :   FOR_EACH_DEP (from, list_type, sd_it, dep)
    1412                 :            :     {
    1413                 :          0 :       dep_def _new_dep, *new_dep = &_new_dep;
    1414                 :            : 
    1415                 :          0 :       copy_dep (new_dep, dep);
    1416                 :          0 :       DEP_CON (new_dep) = to;
    1417                 :          0 :       sd_add_dep (new_dep, resolved_p);
    1418                 :            :     }
    1419                 :          0 : }
    1420                 :            : 
    1421                 :            : /* Remove a dependency referred to by SD_IT.
    1422                 :            :    SD_IT will point to the next dependence after removal.  */
    1423                 :            : void
    1424                 :    5120100 : sd_delete_dep (sd_iterator_def sd_it)
    1425                 :            : {
    1426                 :    5120100 :   dep_node_t n = DEP_LINK_NODE (*sd_it.linkp);
    1427                 :    5120100 :   dep_t dep = DEP_NODE_DEP (n);
    1428                 :    5120100 :   rtx_insn *pro = DEP_PRO (dep);
    1429                 :    5120100 :   rtx_insn *con = DEP_CON (dep);
    1430                 :    5120100 :   deps_list_t con_back_deps;
    1431                 :    5120100 :   deps_list_t pro_forw_deps;
    1432                 :            : 
    1433                 :    5120100 :   if (true_dependency_cache != NULL)
    1434                 :            :     {
    1435                 :        153 :       int elem_luid = INSN_LUID (pro);
    1436                 :        153 :       int insn_luid = INSN_LUID (con);
    1437                 :            : 
    1438                 :        153 :       bitmap_clear_bit (&true_dependency_cache[insn_luid], elem_luid);
    1439                 :        153 :       bitmap_clear_bit (&anti_dependency_cache[insn_luid], elem_luid);
    1440                 :        153 :       bitmap_clear_bit (&control_dependency_cache[insn_luid], elem_luid);
    1441                 :        153 :       bitmap_clear_bit (&output_dependency_cache[insn_luid], elem_luid);
    1442                 :            : 
    1443                 :        153 :       if (current_sched_info->flags & DO_SPECULATION)
    1444                 :          0 :         bitmap_clear_bit (&spec_dependency_cache[insn_luid], elem_luid);
    1445                 :            :     }
    1446                 :            : 
    1447                 :    5120100 :   get_back_and_forw_lists (dep, sd_it.resolved_p,
    1448                 :            :                            &con_back_deps, &pro_forw_deps);
    1449                 :            : 
    1450                 :    5120100 :   remove_from_deps_list (DEP_NODE_BACK (n), con_back_deps);
    1451                 :    5120100 :   remove_from_deps_list (DEP_NODE_FORW (n), pro_forw_deps);
    1452                 :            : 
    1453                 :    5120100 :   delete_dep_node (n);
    1454                 :    5120100 : }
    1455                 :            : 
    1456                 :            : /* Dump size of the lists.  */
    1457                 :            : #define DUMP_LISTS_SIZE (2)
    1458                 :            : 
    1459                 :            : /* Dump dependencies of the lists.  */
    1460                 :            : #define DUMP_LISTS_DEPS (4)
    1461                 :            : 
    1462                 :            : /* Dump all information about the lists.  */
    1463                 :            : #define DUMP_LISTS_ALL (DUMP_LISTS_SIZE | DUMP_LISTS_DEPS)
    1464                 :            : 
    1465                 :            : /* Dump deps_lists of INSN specified by TYPES to DUMP.
    1466                 :            :    FLAGS is a bit mask specifying what information about the lists needs
    1467                 :            :    to be printed.
    1468                 :            :    If FLAGS has the very first bit set, then dump all information about
    1469                 :            :    the lists and propagate this bit into the callee dump functions.  */
    1470                 :            : static void
    1471                 :          0 : dump_lists (FILE *dump, rtx insn, sd_list_types_def types, int flags)
    1472                 :            : {
    1473                 :          0 :   sd_iterator_def sd_it;
    1474                 :          0 :   dep_t dep;
    1475                 :          0 :   int all;
    1476                 :            : 
    1477                 :          0 :   all = (flags & 1);
    1478                 :            : 
    1479                 :          0 :   if (all)
    1480                 :          0 :     flags |= DUMP_LISTS_ALL;
    1481                 :            : 
    1482                 :          0 :   fprintf (dump, "[");
    1483                 :            : 
    1484                 :          0 :   if (flags & DUMP_LISTS_SIZE)
    1485                 :          0 :     fprintf (dump, "%d; ", sd_lists_size (insn, types));
    1486                 :            : 
    1487                 :          0 :   if (flags & DUMP_LISTS_DEPS)
    1488                 :            :     {
    1489                 :          0 :       FOR_EACH_DEP (insn, types, sd_it, dep)
    1490                 :            :         {
    1491                 :          0 :           dump_dep (dump, dep, dump_dep_flags | all);
    1492                 :          0 :           fprintf (dump, " ");
    1493                 :            :         }
    1494                 :            :     }
    1495                 :          0 : }
    1496                 :            : 
    1497                 :            : /* Dump all information about deps_lists of INSN specified by TYPES
    1498                 :            :    to STDERR.  */
    1499                 :            : void
    1500                 :          0 : sd_debug_lists (rtx insn, sd_list_types_def types)
    1501                 :            : {
    1502                 :          0 :   dump_lists (stderr, insn, types, 1);
    1503                 :          0 :   fprintf (stderr, "\n");
    1504                 :          0 : }
    1505                 :            : 
    1506                 :            : /* A wrapper around add_dependence_1, to add a dependence of CON on
    1507                 :            :    PRO, with type DEP_TYPE.  This function implements special handling
    1508                 :            :    for REG_DEP_CONTROL dependencies.  For these, we optionally promote
    1509                 :            :    the type to REG_DEP_ANTI if we can determine that predication is
    1510                 :            :    impossible; otherwise we add additional true dependencies on the
    1511                 :            :    INSN_COND_DEPS list of the jump (which PRO must be).  */
    1512                 :            : void
    1513                 :  373607000 : add_dependence (rtx_insn *con, rtx_insn *pro, enum reg_note dep_type)
    1514                 :            : {
    1515                 :  373607000 :   if (dep_type == REG_DEP_CONTROL
    1516                 :      15544 :       && !(current_sched_info->flags & DO_PREDICATION))
    1517                 :            :     dep_type = REG_DEP_ANTI;
    1518                 :            : 
    1519                 :            :   /* A REG_DEP_CONTROL dependence may be eliminated through predication,
    1520                 :            :      so we must also make the insn dependent on the setter of the
    1521                 :            :      condition.  */
    1522                 :  373592000 :   if (dep_type == REG_DEP_CONTROL)
    1523                 :            :     {
    1524                 :          0 :       rtx_insn *real_pro = pro;
    1525                 :          0 :       rtx_insn *other = real_insn_for_shadow (real_pro);
    1526                 :          0 :       rtx cond;
    1527                 :            : 
    1528                 :          0 :       if (other != NULL_RTX)
    1529                 :          0 :         real_pro = other;
    1530                 :          0 :       cond = sched_get_reverse_condition_uncached (real_pro);
    1531                 :            :       /* Verify that the insn does not use a different value in
    1532                 :            :          the condition register than the one that was present at
    1533                 :            :          the jump.  */
    1534                 :          0 :       if (cond == NULL_RTX)
    1535                 :            :         dep_type = REG_DEP_ANTI;
    1536                 :          0 :       else if (INSN_CACHED_COND (real_pro) == const_true_rtx)
    1537                 :            :         {
    1538                 :            :           HARD_REG_SET uses;
    1539                 :          0 :           CLEAR_HARD_REG_SET (uses);
    1540                 :          0 :           note_uses (&PATTERN (con), record_hard_reg_uses, &uses);
    1541                 :          0 :           if (TEST_HARD_REG_BIT (uses, REGNO (XEXP (cond, 0))))
    1542                 :          0 :             dep_type = REG_DEP_ANTI;
    1543                 :            :         }
    1544                 :          0 :       if (dep_type == REG_DEP_CONTROL)
    1545                 :            :         {
    1546                 :          0 :           if (sched_verbose >= 5)
    1547                 :          0 :             fprintf (sched_dump, "making DEP_CONTROL for %d\n",
    1548                 :          0 :                      INSN_UID (real_pro));
    1549                 :          0 :           add_dependence_list (con, INSN_COND_DEPS (real_pro), 0,
    1550                 :            :                                REG_DEP_TRUE, false);
    1551                 :            :         }
    1552                 :            :     }
    1553                 :            :           
    1554                 :  373607000 :   add_dependence_1 (con, pro, dep_type);
    1555                 :  373607000 : }
    1556                 :            : 
    1557                 :            : /* A convenience wrapper to operate on an entire list.  HARD should be
    1558                 :            :    true if DEP_NONREG should be set on newly created dependencies.  */
    1559                 :            : 
    1560                 :            : static void
    1561                 : 1806850000 : add_dependence_list (rtx_insn *insn, rtx_insn_list *list, int uncond,
    1562                 :            :                      enum reg_note dep_type, bool hard)
    1563                 :            : {
    1564                 : 1806850000 :   mark_as_hard = hard;
    1565                 : 2175440000 :   for (; list; list = list->next ())
    1566                 :            :     {
    1567                 :  300288000 :       if (uncond || ! sched_insns_conditions_mutex_p (insn, list->insn ()))
    1568                 :  300288000 :         add_dependence (insn, list->insn (), dep_type);
    1569                 :            :     }
    1570                 : 1806850000 :   mark_as_hard = false;
    1571                 : 1806850000 : }
    1572                 :            : 
    1573                 :            : /* Similar, but free *LISTP at the same time, when the context
    1574                 :            :    is not readonly.  HARD should be true if DEP_NONREG should be set on
    1575                 :            :    newly created dependencies.  */
    1576                 :            : 
    1577                 :            : static void
    1578                 :  706612000 : add_dependence_list_and_free (class deps_desc *deps, rtx_insn *insn,
    1579                 :            :                               rtx_insn_list **listp,
    1580                 :            :                               int uncond, enum reg_note dep_type, bool hard)
    1581                 :            : {
    1582                 :  706612000 :   add_dependence_list (insn, *listp, uncond, dep_type, hard);
    1583                 :            : 
    1584                 :            :   /* We don't want to short-circuit dependencies involving debug
    1585                 :            :      insns, because they may cause actual dependencies to be
    1586                 :            :      disregarded.  */
    1587                 :  706612000 :   if (deps->readonly || DEBUG_INSN_P (insn))
    1588                 :            :     return;
    1589                 :            : 
    1590                 :  706548000 :   free_INSN_LIST_list (listp);
    1591                 :            : }
    1592                 :            : 
    1593                 :            : /* Remove all occurrences of INSN from LIST.  Return the number of
    1594                 :            :    occurrences removed.  */
    1595                 :            : 
    1596                 :            : static int
    1597                 :      49996 : remove_from_dependence_list (rtx_insn *insn, rtx_insn_list **listp)
    1598                 :            : {
    1599                 :      49996 :   int removed = 0;
    1600                 :            : 
    1601                 :     102004 :   while (*listp)
    1602                 :            :     {
    1603                 :      52008 :       if ((*listp)->insn () == insn)
    1604                 :            :         {
    1605                 :      10713 :           remove_free_INSN_LIST_node (listp);
    1606                 :      10713 :           removed++;
    1607                 :      10713 :           continue;
    1608                 :            :         }
    1609                 :            : 
    1610                 :      41295 :       listp = (rtx_insn_list **)&XEXP (*listp, 1);
    1611                 :            :     }
    1612                 :            : 
    1613                 :      49996 :   return removed;
    1614                 :            : }
    1615                 :            : 
    1616                 :            : /* Same as above, but process two lists at once.  */
    1617                 :            : static int
    1618                 :       4722 : remove_from_both_dependence_lists (rtx_insn *insn,
    1619                 :            :                                    rtx_insn_list **listp,
    1620                 :            :                                    rtx_expr_list **exprp)
    1621                 :            : {
    1622                 :       4722 :   int removed = 0;
    1623                 :            : 
    1624                 :       8361 :   while (*listp)
    1625                 :            :     {
    1626                 :       3639 :       if (XEXP (*listp, 0) == insn)
    1627                 :            :         {
    1628                 :        551 :           remove_free_INSN_LIST_node (listp);
    1629                 :        551 :           remove_free_EXPR_LIST_node (exprp);
    1630                 :        551 :           removed++;
    1631                 :        551 :           continue;
    1632                 :            :         }
    1633                 :            : 
    1634                 :       3088 :       listp = (rtx_insn_list **)&XEXP (*listp, 1);
    1635                 :       3088 :       exprp = (rtx_expr_list **)&XEXP (*exprp, 1);
    1636                 :            :     }
    1637                 :            : 
    1638                 :       4722 :   return removed;
    1639                 :            : }
    1640                 :            : 
    1641                 :            : /* Clear all dependencies for an insn.  */
    1642                 :            : static void
    1643                 :    2374110 : delete_all_dependences (rtx_insn *insn)
    1644                 :            : {
    1645                 :    2374110 :   sd_iterator_def sd_it;
    1646                 :    2374110 :   dep_t dep;
    1647                 :            : 
    1648                 :            :   /* The below cycle can be optimized to clear the caches and back_deps
    1649                 :            :      in one call but that would provoke duplication of code from
    1650                 :            :      delete_dep ().  */
    1651                 :            : 
    1652                 :    2374110 :   for (sd_it = sd_iterator_start (insn, SD_LIST_BACK);
    1653                 :    7443530 :        sd_iterator_cond (&sd_it, &dep);)
    1654                 :    5069420 :     sd_delete_dep (sd_it);
    1655                 :    2374110 : }
    1656                 :            : 
    1657                 :            : /* All insns in a scheduling group except the first should only have
    1658                 :            :    dependencies on the previous insn in the group.  So we find the
    1659                 :            :    first instruction in the scheduling group by walking the dependence
    1660                 :            :    chains backwards. Then we add the dependencies for the group to
    1661                 :            :    the previous nonnote insn.  */
    1662                 :            : 
    1663                 :            : static void
    1664                 :    2374110 : chain_to_prev_insn (rtx_insn *insn)
    1665                 :            : {
    1666                 :    2374110 :   sd_iterator_def sd_it;
    1667                 :    2374110 :   dep_t dep;
    1668                 :    2374110 :   rtx_insn *prev_nonnote;
    1669                 :            : 
    1670                 :    7443530 :   FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
    1671                 :            :     {
    1672                 :    5069420 :       rtx_insn *i = insn;
    1673                 :    5069420 :       rtx_insn *pro = DEP_PRO (dep);
    1674                 :            : 
    1675                 :    5070100 :       do
    1676                 :            :         {
    1677                 :    5070100 :           i = prev_nonnote_insn (i);
    1678                 :            : 
    1679                 :    5070100 :           if (pro == i)
    1680                 :    2374110 :             goto next_link;
    1681                 :    2695980 :         } while (SCHED_GROUP_P (i) || DEBUG_INSN_P (i));
    1682                 :            : 
    1683                 :    2695300 :       if (! sched_insns_conditions_mutex_p (i, pro))
    1684                 :    2695300 :         add_dependence (i, pro, DEP_TYPE (dep));
    1685                 :    5069420 :     next_link:;
    1686                 :            :     }
    1687                 :            : 
    1688                 :    2374110 :   delete_all_dependences (insn);
    1689                 :            : 
    1690                 :    2374110 :   prev_nonnote = prev_nonnote_nondebug_insn (insn);
    1691                 :    2374110 :   if (BLOCK_FOR_INSN (insn) == BLOCK_FOR_INSN (prev_nonnote)
    1692                 :    2374110 :       && ! sched_insns_conditions_mutex_p (insn, prev_nonnote))
    1693                 :    2374110 :     add_dependence (insn, prev_nonnote, REG_DEP_ANTI);
    1694                 :    2374110 : }
    1695                 :            : 
    1696                 :            : /* Process an insn's memory dependencies.  There are four kinds of
    1697                 :            :    dependencies:
    1698                 :            : 
    1699                 :            :    (0) read dependence: read follows read
    1700                 :            :    (1) true dependence: read follows write
    1701                 :            :    (2) output dependence: write follows write
    1702                 :            :    (3) anti dependence: write follows read
    1703                 :            : 
    1704                 :            :    We are careful to build only dependencies which actually exist, and
    1705                 :            :    use transitivity to avoid building too many links.  */
    1706                 :            : 
    1707                 :            : /* Add an INSN and MEM reference pair to a pending INSN_LIST and MEM_LIST.
    1708                 :            :    The MEM is a memory reference contained within INSN, which we are saving
    1709                 :            :    so that we can do memory aliasing on it.  */
    1710                 :            : 
    1711                 :            : static void
    1712                 :   21550700 : add_insn_mem_dependence (class deps_desc *deps, bool read_p,
    1713                 :            :                          rtx_insn *insn, rtx mem)
    1714                 :            : {
    1715                 :   21550700 :   rtx_insn_list **insn_list;
    1716                 :   21550700 :   rtx_insn_list *insn_node;
    1717                 :   21550700 :   rtx_expr_list **mem_list;
    1718                 :   21550700 :   rtx_expr_list *mem_node;
    1719                 :            : 
    1720                 :   21550700 :   gcc_assert (!deps->readonly);
    1721                 :   21550700 :   if (read_p)
    1722                 :            :     {
    1723                 :   12421200 :       insn_list = &deps->pending_read_insns;
    1724                 :   12421200 :       mem_list = &deps->pending_read_mems;
    1725                 :   12421200 :       if (!DEBUG_INSN_P (insn))
    1726                 :   11427400 :         deps->pending_read_list_length++;
    1727                 :            :     }
    1728                 :            :   else
    1729                 :            :     {
    1730                 :    9129550 :       insn_list = &deps->pending_write_insns;
    1731                 :    9129550 :       mem_list = &deps->pending_write_mems;
    1732                 :    9129550 :       deps->pending_write_list_length++;
    1733                 :            :     }
    1734                 :            : 
    1735                 :   21550700 :   insn_node = alloc_INSN_LIST (insn, *insn_list);
    1736                 :   21550700 :   *insn_list = insn_node;
    1737                 :            : 
    1738                 :   21550700 :   if (sched_deps_info->use_cselib)
    1739                 :            :     {
    1740                 :        595 :       mem = shallow_copy_rtx (mem);
    1741                 :        595 :       XEXP (mem, 0) = cselib_subst_to_values_from_insn (XEXP (mem, 0),
    1742                 :        595 :                                                         GET_MODE (mem), insn);
    1743                 :            :     }
    1744                 :   21550700 :   mem_node = alloc_EXPR_LIST (VOIDmode, canon_rtx (mem), *mem_list);
    1745                 :   21550700 :   *mem_list = mem_node;
    1746                 :   21550700 : }
    1747                 :            : 
    1748                 :            : /* Make a dependency between every memory reference on the pending lists
    1749                 :            :    and INSN, thus flushing the pending lists.  FOR_READ is true if emitting
    1750                 :            :    dependencies for a read operation, similarly with FOR_WRITE.  */
    1751                 :            : 
    1752                 :            : static void
    1753                 :    6408280 : flush_pending_lists (class deps_desc *deps, rtx_insn *insn, int for_read,
    1754                 :            :                      int for_write)
    1755                 :            : {
    1756                 :    6408280 :   if (for_write)
    1757                 :            :     {
    1758                 :    6226010 :       add_dependence_list_and_free (deps, insn, &deps->pending_read_insns,
    1759                 :            :                                     1, REG_DEP_ANTI, true);
    1760                 :    6226010 :       if (!deps->readonly)
    1761                 :            :         {
    1762                 :    6225050 :           free_EXPR_LIST_list (&deps->pending_read_mems);
    1763                 :    6225050 :           deps->pending_read_list_length = 0;
    1764                 :            :         }
    1765                 :            :     }
    1766                 :            : 
    1767                 :    6426190 :   add_dependence_list_and_free (deps, insn, &deps->pending_write_insns, 1,
    1768                 :            :                                 for_read ? REG_DEP_ANTI : REG_DEP_OUTPUT,
    1769                 :            :                                 true);
    1770                 :            : 
    1771                 :    6408280 :   add_dependence_list_and_free (deps, insn,
    1772                 :            :                                 &deps->last_pending_memory_flush, 1,
    1773                 :            :                                 for_read ? REG_DEP_ANTI : REG_DEP_OUTPUT,
    1774                 :            :                                 true);
    1775                 :            : 
    1776                 :    6408280 :   add_dependence_list_and_free (deps, insn, &deps->pending_jump_insns, 1,
    1777                 :            :                                 REG_DEP_ANTI, true);
    1778                 :            : 
    1779                 :    6408280 :   if (DEBUG_INSN_P (insn))
    1780                 :            :     {
    1781                 :          0 :       if (for_write)
    1782                 :          0 :         free_INSN_LIST_list (&deps->pending_read_insns);
    1783                 :          0 :       free_INSN_LIST_list (&deps->pending_write_insns);
    1784                 :          0 :       free_INSN_LIST_list (&deps->last_pending_memory_flush);
    1785                 :          0 :       free_INSN_LIST_list (&deps->pending_jump_insns);
    1786                 :            :     }
    1787                 :            : 
    1788                 :    6408280 :   if (!deps->readonly)
    1789                 :            :     {
    1790                 :    6407260 :       free_EXPR_LIST_list (&deps->pending_write_mems);
    1791                 :    6407260 :       deps->pending_write_list_length = 0;
    1792                 :            : 
    1793                 :    6407260 :       deps->last_pending_memory_flush = alloc_INSN_LIST (insn, NULL_RTX);
    1794                 :    6407260 :       deps->pending_flush_length = 1;
    1795                 :            :     }
    1796                 :    6408280 :   mark_as_hard = false;
    1797                 :    6408280 : }
    1798                 :            : 
    1799                 :            : /* Instruction which dependencies we are analyzing.  */
    1800                 :            : static rtx_insn *cur_insn = NULL;
    1801                 :            : 
    1802                 :            : /* Implement hooks for haifa scheduler.  */
    1803                 :            : 
    1804                 :            : static void
    1805                 :   70883600 : haifa_start_insn (rtx_insn *insn)
    1806                 :            : {
    1807                 :   70883600 :   gcc_assert (insn && !cur_insn);
    1808                 :            : 
    1809                 :   70883600 :   cur_insn = insn;
    1810                 :   70883600 : }
    1811                 :            : 
    1812                 :            : static void
    1813                 :   70883600 : haifa_finish_insn (void)
    1814                 :            : {
    1815                 :   70883600 :   cur_insn = NULL;
    1816                 :   70883600 : }
    1817                 :            : 
    1818                 :            : void
    1819                 :   24484600 : haifa_note_reg_set (int regno)
    1820                 :            : {
    1821                 :   24484600 :   SET_REGNO_REG_SET (reg_pending_sets, regno);
    1822                 :   24484600 : }
    1823                 :            : 
    1824                 :            : void
    1825                 :    8919770 : haifa_note_reg_clobber (int regno)
    1826                 :            : {
    1827                 :    8919770 :   SET_REGNO_REG_SET (reg_pending_clobbers, regno);
    1828                 :    8919770 : }
    1829                 :            : 
    1830                 :            : void
    1831                 :   50776600 : haifa_note_reg_use (int regno)
    1832                 :            : {
    1833                 :   50776600 :   SET_REGNO_REG_SET (reg_pending_uses, regno);
    1834                 :   50776600 : }
    1835                 :            : 
    1836                 :            : static void
    1837                 :   15041900 : haifa_note_mem_dep (rtx mem, rtx pending_mem, rtx_insn *pending_insn, ds_t ds)
    1838                 :            : {
    1839                 :   15041900 :   if (!(ds & SPECULATIVE))
    1840                 :            :     {
    1841                 :            :       mem = NULL_RTX;
    1842                 :            :       pending_mem = NULL_RTX;
    1843                 :            :     }
    1844                 :            :   else
    1845                 :          0 :     gcc_assert (ds & BEGIN_DATA);
    1846                 :            : 
    1847                 :   15041900 :   {
    1848                 :   15041900 :     dep_def _dep, *dep = &_dep;
    1849                 :            : 
    1850                 :   15041900 :     init_dep_1 (dep, pending_insn, cur_insn, ds_to_dt (ds),
    1851                 :   15041900 :                 current_sched_info->flags & USE_DEPS_LIST ? ds : 0);
    1852                 :   15041900 :     DEP_NONREG (dep) = 1;
    1853                 :   15041900 :     maybe_add_or_update_dep_1 (dep, false, pending_mem, mem);
    1854                 :            :   }
    1855                 :            : 
    1856                 :   15041900 : }
    1857                 :            : 
    1858                 :            : static void
    1859                 :  378436000 : haifa_note_dep (rtx_insn *elem, ds_t ds)
    1860                 :            : {
    1861                 :  378436000 :   dep_def _dep;
    1862                 :  378436000 :   dep_t dep = &_dep;
    1863                 :            : 
    1864                 :  378436000 :   init_dep (dep, elem, cur_insn, ds_to_dt (ds));
    1865                 :  378436000 :   if (mark_as_hard)
    1866                 :  175476000 :     DEP_NONREG (dep) = 1;
    1867                 :  378436000 :   maybe_add_or_update_dep_1 (dep, false, NULL_RTX, NULL_RTX);
    1868                 :  378436000 : }
    1869                 :            : 
    1870                 :            : static void
    1871                 :   50796800 : note_reg_use (int r)
    1872                 :            : {
    1873                 :          0 :   if (sched_deps_info->note_reg_use)
    1874                 :   50796800 :     sched_deps_info->note_reg_use (r);
    1875                 :          0 : }
    1876                 :            : 
    1877                 :            : static void
    1878                 :   24504000 : note_reg_set (int r)
    1879                 :            : {
    1880                 :          0 :   if (sched_deps_info->note_reg_set)
    1881                 :   24504000 :     sched_deps_info->note_reg_set (r);
    1882                 :          0 : }
    1883                 :            : 
    1884                 :            : static void
    1885                 :    8921510 : note_reg_clobber (int r)
    1886                 :            : {
    1887                 :          0 :   if (sched_deps_info->note_reg_clobber)
    1888                 :    8921510 :     sched_deps_info->note_reg_clobber (r);
    1889                 :          0 : }
    1890                 :            : 
    1891                 :            : static void
    1892                 :   15045900 : note_mem_dep (rtx m1, rtx m2, rtx_insn *e, ds_t ds)
    1893                 :            : {
    1894                 :   15045900 :   if (sched_deps_info->note_mem_dep)
    1895                 :   15044800 :     sched_deps_info->note_mem_dep (m1, m2, e, ds);
    1896                 :          0 : }
    1897                 :            : 
    1898                 :            : static void
    1899                 :  378473000 : note_dep (rtx_insn *e, ds_t ds)
    1900                 :            : {
    1901                 :          0 :   if (sched_deps_info->note_dep)
    1902                 :  378460000 :     sched_deps_info->note_dep (e, ds);
    1903                 :          0 : }
    1904                 :            : 
    1905                 :            : /* Return corresponding to DS reg_note.  */
    1906                 :            : enum reg_note
    1907                 :  393505000 : ds_to_dt (ds_t ds)
    1908                 :            : {
    1909                 :  393505000 :   if (ds & DEP_TRUE)
    1910                 :            :     return REG_DEP_TRUE;
    1911                 :  314664000 :   else if (ds & DEP_OUTPUT)
    1912                 :            :     return REG_DEP_OUTPUT;
    1913                 :  258602000 :   else if (ds & DEP_ANTI)
    1914                 :            :     return REG_DEP_ANTI;
    1915                 :            :   else
    1916                 :            :     {
    1917                 :          0 :       gcc_assert (ds & DEP_CONTROL);
    1918                 :            :       return REG_DEP_CONTROL;
    1919                 :            :     }
    1920                 :            : }
    1921                 :            : 
    1922                 :            : 
    1923                 :            : 
    1924                 :            : /* Functions for computation of info needed for register pressure
    1925                 :            :    sensitive insn scheduling.  */
    1926                 :            : 
    1927                 :            : 
    1928                 :            : /* Allocate and return reg_use_data structure for REGNO and INSN.  */
    1929                 :            : static struct reg_use_data *
    1930                 :       3659 : create_insn_reg_use (int regno, rtx_insn *insn)
    1931                 :            : {
    1932                 :       3659 :   struct reg_use_data *use;
    1933                 :            : 
    1934                 :       3659 :   use = (struct reg_use_data *) xmalloc (sizeof (struct reg_use_data));
    1935                 :       3659 :   use->regno = regno;
    1936                 :       3659 :   use->insn = insn;
    1937                 :       3659 :   use->next_insn_use = INSN_REG_USE_LIST (insn);
    1938                 :       3659 :   INSN_REG_USE_LIST (insn) = use;
    1939                 :       3659 :   return use;
    1940                 :            : }
    1941                 :            : 
    1942                 :            : /* Allocate reg_set_data structure for REGNO and INSN.  */
    1943                 :            : static void
    1944                 :       3991 : create_insn_reg_set (int regno, rtx insn)
    1945                 :            : {
    1946                 :       3991 :   struct reg_set_data *set;
    1947                 :            : 
    1948                 :       3991 :   set = (struct reg_set_data *) xmalloc (sizeof (struct reg_set_data));
    1949                 :       3991 :   set->regno = regno;
    1950                 :       3991 :   set->insn = insn;
    1951                 :       3991 :   set->next_insn_set = INSN_REG_SET_LIST (insn);
    1952                 :       3991 :   INSN_REG_SET_LIST (insn) = set;
    1953                 :       3991 : }
    1954                 :            : 
    1955                 :            : /* Set up insn register uses for INSN and dependency context DEPS.  */
    1956                 :            : static void
    1957                 :       7777 : setup_insn_reg_uses (class deps_desc *deps, rtx_insn *insn)
    1958                 :            : {
    1959                 :       7777 :   unsigned i;
    1960                 :       7777 :   reg_set_iterator rsi;
    1961                 :       7777 :   struct reg_use_data *use, *use2, *next;
    1962                 :       7777 :   struct deps_reg *reg_last;
    1963                 :            : 
    1964                 :      15531 :   EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
    1965                 :            :     {
    1966                 :       9507 :       if (i < FIRST_PSEUDO_REGISTER
    1967                 :       7754 :           && TEST_HARD_REG_BIT (ira_no_alloc_regs, i))
    1968                 :       1753 :         continue;
    1969                 :            : 
    1970                 :       6001 :       if (find_regno_note (insn, REG_DEAD, i) == NULL_RTX
    1971                 :       2797 :           && ! REGNO_REG_SET_P (reg_pending_sets, i)
    1972                 :       8544 :           && ! REGNO_REG_SET_P (reg_pending_clobbers, i))
    1973                 :            :         /* Ignore use which is not dying.  */
    1974                 :       2543 :         continue;
    1975                 :            : 
    1976                 :       3458 :       use = create_insn_reg_use (i, insn);
    1977                 :       3458 :       use->next_regno_use = use;
    1978                 :       3458 :       reg_last = &deps->reg_last[i];
    1979                 :            : 
    1980                 :            :       /* Create the cycle list of uses.  */
    1981                 :       7955 :       for (rtx_insn_list *list = reg_last->uses; list; list = list->next ())
    1982                 :            :         {
    1983                 :        201 :           use2 = create_insn_reg_use (i, list->insn ());
    1984                 :        201 :           next = use->next_regno_use;
    1985                 :        201 :           use->next_regno_use = use2;
    1986                 :        201 :           use2->next_regno_use = next;
    1987                 :            :         }
    1988                 :            :     }
    1989                 :       7777 : }
    1990                 :            : 
    1991                 :            : /* Register pressure info for the currently processed insn.  */
    1992                 :            : static struct reg_pressure_data reg_pressure_info[N_REG_CLASSES];
    1993                 :            : 
    1994                 :            : /* Return TRUE if INSN has the use structure for REGNO.  */
    1995                 :            : static bool
    1996                 :       3991 : insn_use_p (rtx insn, int regno)
    1997                 :            : {
    1998                 :       3991 :   struct reg_use_data *use;
    1999                 :            : 
    2000                 :       5215 :   for (use = INSN_REG_USE_LIST (insn); use != NULL; use = use->next_insn_use)
    2001                 :       1454 :     if (use->regno == regno)
    2002                 :            :       return true;
    2003                 :            :   return false;
    2004                 :            : }
    2005                 :            : 
    2006                 :            : /* Update the register pressure info after birth of pseudo register REGNO
    2007                 :            :    in INSN.  Arguments CLOBBER_P and UNUSED_P say correspondingly that
    2008                 :            :    the register is in clobber or unused after the insn.  */
    2009                 :            : static void
    2010                 :       2187 : mark_insn_pseudo_birth (rtx insn, int regno, bool clobber_p, bool unused_p)
    2011                 :            : {
    2012                 :       2187 :   int incr, new_incr;
    2013                 :       2187 :   enum reg_class cl;
    2014                 :            : 
    2015                 :       2187 :   gcc_assert (regno >= FIRST_PSEUDO_REGISTER);
    2016                 :       2187 :   cl = sched_regno_pressure_class[regno];
    2017                 :       2187 :   if (cl != NO_REGS)
    2018                 :            :     {
    2019                 :       2177 :       incr = ira_reg_class_max_nregs[cl][PSEUDO_REGNO_MODE (regno)];
    2020                 :       2177 :       if (clobber_p)
    2021                 :            :         {
    2022                 :          8 :           new_incr = reg_pressure_info[cl].clobber_increase + incr;
    2023                 :          8 :           reg_pressure_info[cl].clobber_increase = new_incr;
    2024                 :            :         }
    2025                 :       2169 :       else if (unused_p)
    2026                 :            :         {
    2027                 :         43 :           new_incr = reg_pressure_info[cl].unused_set_increase + incr;
    2028                 :         43 :           reg_pressure_info[cl].unused_set_increase = new_incr;
    2029                 :            :         }
    2030                 :            :       else
    2031                 :            :         {
    2032                 :       2126 :           new_incr = reg_pressure_info[cl].set_increase + incr;
    2033                 :       2126 :           reg_pressure_info[cl].set_increase = new_incr;
    2034                 :       2126 :           if (! insn_use_p (insn, regno))
    2035                 :       1990 :             reg_pressure_info[cl].change += incr;
    2036                 :       2126 :           create_insn_reg_set (regno, insn);
    2037                 :            :         }
    2038                 :       2177 :       gcc_assert (new_incr < (1 << INCREASE_BITS));
    2039                 :            :     }
    2040                 :       2187 : }
    2041                 :            : 
    2042                 :            : /* Like mark_insn_pseudo_regno_birth except that NREGS saying how many
    2043                 :            :    hard registers involved in the birth.  */
    2044                 :            : static void
    2045                 :       2794 : mark_insn_hard_regno_birth (rtx insn, int regno, int nregs,
    2046                 :            :                             bool clobber_p, bool unused_p)
    2047                 :            : {
    2048                 :       2794 :   enum reg_class cl;
    2049                 :       2794 :   int new_incr, last = regno + nregs;
    2050                 :            : 
    2051                 :       5594 :   while (regno < last)
    2052                 :            :     {
    2053                 :       2800 :       gcc_assert (regno < FIRST_PSEUDO_REGISTER);
    2054                 :       2800 :       if (! TEST_HARD_REG_BIT (ira_no_alloc_regs, regno))
    2055                 :            :         {
    2056                 :       1988 :           cl = sched_regno_pressure_class[regno];
    2057                 :       1988 :           if (cl != NO_REGS)
    2058                 :            :             {
    2059                 :       1988 :               if (clobber_p)
    2060                 :            :                 {
    2061                 :          1 :                   new_incr = reg_pressure_info[cl].clobber_increase + 1;
    2062                 :          1 :                   reg_pressure_info[cl].clobber_increase = new_incr;
    2063                 :            :                 }
    2064                 :       1987 :               else if (unused_p)
    2065                 :            :                 {
    2066                 :        122 :                   new_incr = reg_pressure_info[cl].unused_set_increase + 1;
    2067                 :        122 :                   reg_pressure_info[cl].unused_set_increase = new_incr;
    2068                 :            :                 }
    2069                 :            :               else
    2070                 :            :                 {
    2071                 :       1865 :                   new_incr = reg_pressure_info[cl].set_increase + 1;
    2072                 :       1865 :                   reg_pressure_info[cl].set_increase = new_incr;
    2073                 :       1865 :                   if (! insn_use_p (insn, regno))
    2074                 :       1771 :                     reg_pressure_info[cl].change += 1;
    2075                 :       1865 :                   create_insn_reg_set (regno, insn);
    2076                 :            :                 }
    2077                 :       1988 :               gcc_assert (new_incr < (1 << INCREASE_BITS));
    2078                 :            :             }
    2079                 :            :         }
    2080                 :       2800 :       regno++;
    2081                 :            :     }
    2082                 :       2794 : }
    2083                 :            : 
    2084                 :            : /* Update the register pressure info after birth of pseudo or hard
    2085                 :            :    register REG in INSN.  Arguments CLOBBER_P and UNUSED_P say
    2086                 :            :    correspondingly that the register is in clobber or unused after the
    2087                 :            :    insn.  */
    2088                 :            : static void
    2089                 :       6311 : mark_insn_reg_birth (rtx insn, rtx reg, bool clobber_p, bool unused_p)
    2090                 :            : {
    2091                 :       6311 :   int regno;
    2092                 :            : 
    2093                 :       6311 :   if (GET_CODE (reg) == SUBREG)
    2094                 :          0 :     reg = SUBREG_REG (reg);
    2095                 :            : 
    2096                 :       6311 :   if (! REG_P (reg))
    2097                 :            :     return;
    2098                 :            : 
    2099                 :       4981 :   regno = REGNO (reg);
    2100                 :       4981 :   if (regno < FIRST_PSEUDO_REGISTER)
    2101                 :       2794 :     mark_insn_hard_regno_birth (insn, regno, REG_NREGS (reg),
    2102                 :            :                                 clobber_p, unused_p);
    2103                 :            :   else
    2104                 :       2187 :     mark_insn_pseudo_birth (insn, regno, clobber_p, unused_p);
    2105                 :            : }
    2106                 :            : 
    2107                 :            : /* Update the register pressure info after death of pseudo register
    2108                 :            :    REGNO.  */
    2109                 :            : static void
    2110                 :       1303 : mark_pseudo_death (int regno)
    2111                 :            : {
    2112                 :       1303 :   int incr;
    2113                 :       1303 :   enum reg_class cl;
    2114                 :            : 
    2115                 :       1303 :   gcc_assert (regno >= FIRST_PSEUDO_REGISTER);
    2116                 :       1303 :   cl = sched_regno_pressure_class[regno];
    2117                 :       1303 :   if (cl != NO_REGS)
    2118                 :            :     {
    2119                 :       1293 :       incr = ira_reg_class_max_nregs[cl][PSEUDO_REGNO_MODE (regno)];
    2120                 :       1293 :       reg_pressure_info[cl].change -= incr;
    2121                 :            :     }
    2122                 :       1303 : }
    2123                 :            : 
    2124                 :            : /* Like mark_pseudo_death except that NREGS saying how many hard
    2125                 :            :    registers involved in the death.  */
    2126                 :            : static void
    2127                 :       2389 : mark_hard_regno_death (int regno, int nregs)
    2128                 :            : {
    2129                 :       2389 :   enum reg_class cl;
    2130                 :       2389 :   int last = regno + nregs;
    2131                 :            : 
    2132                 :       4780 :   while (regno < last)
    2133                 :            :     {
    2134                 :       2391 :       gcc_assert (regno < FIRST_PSEUDO_REGISTER);
    2135                 :       2391 :       if (! TEST_HARD_REG_BIT (ira_no_alloc_regs, regno))
    2136                 :            :         {
    2137                 :       1901 :           cl = sched_regno_pressure_class[regno];
    2138                 :       1901 :           if (cl != NO_REGS)
    2139                 :       1901 :             reg_pressure_info[cl].change -= 1;
    2140                 :            :         }
    2141                 :       2391 :       regno++;
    2142                 :            :     }
    2143                 :       2389 : }
    2144                 :            : 
    2145                 :            : /* Update the register pressure info after death of pseudo or hard
    2146                 :            :    register REG.  */
    2147                 :            : static void
    2148                 :       3692 : mark_reg_death (rtx reg)
    2149                 :            : {
    2150                 :       3692 :   int regno;
    2151                 :            : 
    2152                 :       3692 :   if (GET_CODE (reg) == SUBREG)
    2153                 :          0 :     reg = SUBREG_REG (reg);
    2154                 :            : 
    2155                 :       3692 :   if (! REG_P (reg))
    2156                 :            :     return;
    2157                 :            : 
    2158                 :       3692 :   regno = REGNO (reg);
    2159                 :       3692 :   if (regno < FIRST_PSEUDO_REGISTER)
    2160                 :       2389 :     mark_hard_regno_death (regno, REG_NREGS (reg));
    2161                 :            :   else
    2162                 :       1303 :     mark_pseudo_death (regno);
    2163                 :            : }
    2164                 :            : 
    2165                 :            : /* Process SETTER of REG.  DATA is an insn containing the setter.  */
    2166                 :            : static void
    2167                 :       6311 : mark_insn_reg_store (rtx reg, const_rtx setter, void *data)
    2168                 :            : {
    2169                 :       6311 :   if (setter != NULL_RTX && GET_CODE (setter) != SET)
    2170                 :            :     return;
    2171                 :       5982 :   mark_insn_reg_birth
    2172                 :       5982 :     ((rtx) data, reg, false,
    2173                 :       5982 :      find_reg_note ((const_rtx) data, REG_UNUSED, reg) != NULL_RTX);
    2174                 :            : }
    2175                 :            : 
    2176                 :            : /* Like mark_insn_reg_store except notice just CLOBBERs; ignore SETs.  */
    2177                 :            : static void
    2178                 :       6311 : mark_insn_reg_clobber (rtx reg, const_rtx setter, void *data)
    2179                 :            : {
    2180                 :       6311 :   if (GET_CODE (setter) == CLOBBER)
    2181                 :        329 :     mark_insn_reg_birth ((rtx) data, reg, true, false);
    2182                 :       6311 : }
    2183                 :            : 
    2184                 :            : /* Set up reg pressure info related to INSN.  */
    2185                 :            : void
    2186                 :       7777 : init_insn_reg_pressure_info (rtx_insn *insn)
    2187                 :            : {
    2188                 :       7777 :   int i, len;
    2189                 :       7777 :   enum reg_class cl;
    2190                 :       7777 :   static struct reg_pressure_data *pressure_info;
    2191                 :       7777 :   rtx link;
    2192                 :            : 
    2193                 :       7777 :   gcc_assert (sched_pressure != SCHED_PRESSURE_NONE);
    2194                 :            : 
    2195                 :       7777 :   if (! INSN_P (insn))
    2196                 :            :     return;
    2197                 :            : 
    2198                 :      38885 :   for (i = 0; i < ira_pressure_classes_num; i++)
    2199                 :            :     {
    2200                 :      31108 :       cl = ira_pressure_classes[i];
    2201                 :      31108 :       reg_pressure_info[cl].clobber_increase = 0;
    2202                 :      31108 :       reg_pressure_info[cl].set_increase = 0;
    2203                 :      31108 :       reg_pressure_info[cl].unused_set_increase = 0;
    2204                 :      31108 :       reg_pressure_info[cl].change = 0;
    2205                 :            :     }
    2206                 :            : 
    2207                 :       7777 :   note_stores (insn, mark_insn_reg_clobber, insn);
    2208                 :            : 
    2209                 :       7777 :   note_stores (insn, mark_insn_reg_store, insn);
    2210                 :            : 
    2211                 :       7777 :   if (AUTO_INC_DEC)
    2212                 :            :     for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2213                 :            :       if (REG_NOTE_KIND (link) == REG_INC)
    2214                 :            :         mark_insn_reg_store (XEXP (link, 0), NULL_RTX, insn);
    2215                 :            : 
    2216                 :      14129 :   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2217                 :       6352 :     if (REG_NOTE_KIND (link) == REG_DEAD)
    2218                 :       3692 :       mark_reg_death (XEXP (link, 0));
    2219                 :            : 
    2220                 :       7777 :   len = sizeof (struct reg_pressure_data) * ira_pressure_classes_num;
    2221                 :       7777 :   pressure_info
    2222                 :       7777 :     = INSN_REG_PRESSURE (insn) = (struct reg_pressure_data *) xmalloc (len);
    2223                 :       7777 :   if (sched_pressure == SCHED_PRESSURE_WEIGHTED)
    2224                 :       7777 :     INSN_MAX_REG_PRESSURE (insn) = (int *) xcalloc (ira_pressure_classes_num
    2225                 :            :                                                     * sizeof (int), 1);
    2226                 :      38885 :   for (i = 0; i < ira_pressure_classes_num; i++)
    2227                 :            :     {
    2228                 :      31108 :       cl = ira_pressure_classes[i];
    2229                 :      31108 :       pressure_info[i].clobber_increase
    2230                 :      31108 :         = reg_pressure_info[cl].clobber_increase;
    2231                 :      31108 :       pressure_info[i].set_increase = reg_pressure_info[cl].set_increase;
    2232                 :      31108 :       pressure_info[i].unused_set_increase
    2233                 :      31108 :         = reg_pressure_info[cl].unused_set_increase;
    2234                 :      31108 :       pressure_info[i].change = reg_pressure_info[cl].change;
    2235                 :            :     }
    2236                 :            : }
    2237                 :            : 
    2238                 :            : 
    2239                 :            : 
    2240                 :            : 
    2241                 :            : /* Internal variable for sched_analyze_[12] () functions.
    2242                 :            :    If it is nonzero, this means that sched_analyze_[12] looks
    2243                 :            :    at the most toplevel SET.  */
    2244                 :            : static bool can_start_lhs_rhs_p;
    2245                 :            : 
    2246                 :            : /* Extend reg info for the deps context DEPS given that
    2247                 :            :    we have just generated a register numbered REGNO.  */
    2248                 :            : static void
    2249                 :        272 : extend_deps_reg_info (class deps_desc *deps, int regno)
    2250                 :            : {
    2251                 :        272 :   int max_regno = regno + 1;
    2252                 :            : 
    2253                 :        272 :   gcc_assert (!reload_completed);
    2254                 :            : 
    2255                 :            :   /* In a readonly context, it would not hurt to extend info,
    2256                 :            :      but it should not be needed.  */
    2257                 :        272 :   if (reload_completed && deps->readonly)
    2258                 :            :     {
    2259                 :            :       deps->max_reg = max_regno;
    2260                 :            :       return;
    2261                 :            :     }
    2262                 :            : 
    2263                 :        272 :   if (max_regno > deps->max_reg)
    2264                 :            :     {
    2265                 :         47 :       deps->reg_last = XRESIZEVEC (struct deps_reg, deps->reg_last,
    2266                 :            :                                    max_regno);
    2267                 :         47 :       memset (&deps->reg_last[deps->max_reg],
    2268                 :         47 :               0, (max_regno - deps->max_reg)
    2269                 :            :               * sizeof (struct deps_reg));
    2270                 :         47 :       deps->max_reg = max_regno;
    2271                 :            :     }
    2272                 :            : }
    2273                 :            : 
    2274                 :            : /* Extends REG_INFO_P if needed.  */
    2275                 :            : void
    2276                 :   84041500 : maybe_extend_reg_info_p (void)
    2277                 :            : {
    2278                 :            :   /* Extend REG_INFO_P, if needed.  */
    2279                 :   84041500 :   if ((unsigned int)max_regno - 1 >= reg_info_p_size)
    2280                 :            :     {
    2281                 :         20 :       size_t new_reg_info_p_size = max_regno + 128;
    2282                 :            : 
    2283                 :         20 :       gcc_assert (!reload_completed && sel_sched_p ());
    2284                 :            : 
    2285                 :         20 :       reg_info_p = (struct reg_info_t *) xrecalloc (reg_info_p,
    2286                 :            :                                                     new_reg_info_p_size,
    2287                 :            :                                                     reg_info_p_size,
    2288                 :            :                                                     sizeof (*reg_info_p));
    2289                 :         20 :       reg_info_p_size = new_reg_info_p_size;
    2290                 :            :     }
    2291                 :   84041500 : }
    2292                 :            : 
    2293                 :            : /* Analyze a single reference to register (reg:MODE REGNO) in INSN.
    2294                 :            :    The type of the reference is specified by REF and can be SET,
    2295                 :            :    CLOBBER, PRE_DEC, POST_DEC, PRE_INC, POST_INC or USE.  */
    2296                 :            : 
    2297                 :            : static void
    2298                 :   84041100 : sched_analyze_reg (class deps_desc *deps, int regno, machine_mode mode,
    2299                 :            :                    enum rtx_code ref, rtx_insn *insn)
    2300                 :            : {
    2301                 :            :   /* We could emit new pseudos in renaming.  Extend the reg structures.  */
    2302                 :      58285 :   if (!reload_completed && sel_sched_p ()
    2303                 :   84078600 :       && (regno >= max_reg_num () - 1 || regno >= deps->max_reg))
    2304                 :        272 :     extend_deps_reg_info (deps, regno);
    2305                 :            : 
    2306                 :   84041100 :   maybe_extend_reg_info_p ();
    2307                 :            : 
    2308                 :            :   /* A hard reg in a wide mode may really be multiple registers.
    2309                 :            :      If so, mark all of them just like the first.  */
    2310                 :   84041100 :   if (regno < FIRST_PSEUDO_REGISTER)
    2311                 :            :     {
    2312                 :   83997300 :       int i = hard_regno_nregs (regno, mode);
    2313                 :   83997300 :       if (ref == SET)
    2314                 :            :         {
    2315                 :   48868500 :           while (--i >= 0)
    2316                 :   48868500 :             note_reg_set (regno + i);
    2317                 :            :         }
    2318                 :   59612600 :       else if (ref == USE)
    2319                 :            :         {
    2320                 :  101465000 :           while (--i >= 0)
    2321                 :  101465000 :             note_reg_use (regno + i);
    2322                 :            :         }
    2323                 :            :       else
    2324                 :            :         {
    2325                 :   17842800 :           while (--i >= 0)
    2326                 :   17842800 :             note_reg_clobber (regno + i);
    2327                 :            :         }
    2328                 :            :     }
    2329                 :            : 
    2330                 :            :   /* ??? Reload sometimes emits USEs and CLOBBERs of pseudos that
    2331                 :            :      it does not reload.  Ignore these as they have served their
    2332                 :            :      purpose already.  */
    2333                 :      43715 :   else if (regno >= deps->max_reg)
    2334                 :            :     {
    2335                 :          0 :       enum rtx_code code = GET_CODE (PATTERN (insn));
    2336                 :          0 :       gcc_assert (code == USE || code == CLOBBER);
    2337                 :            :     }
    2338                 :            : 
    2339                 :            :   else
    2340                 :            :     {
    2341                 :      43715 :       if (ref == SET)
    2342                 :      20279 :         note_reg_set (regno);
    2343                 :      23436 :       else if (ref == USE)
    2344                 :      23421 :         note_reg_use (regno);
    2345                 :            :       else
    2346                 :         15 :         note_reg_clobber (regno);
    2347                 :            : 
    2348                 :            :       /* Pseudos that are REG_EQUIV to something may be replaced
    2349                 :            :          by that during reloading.  We need only add dependencies for
    2350                 :            :         the address in the REG_EQUIV note.  */
    2351                 :      43715 :       if (!reload_completed && get_reg_known_equiv_p (regno))
    2352                 :            :         {
    2353                 :          0 :           rtx t = get_reg_known_value (regno);
    2354                 :          0 :           if (MEM_P (t))
    2355                 :          0 :             sched_analyze_2 (deps, XEXP (t, 0), insn);
    2356                 :            :         }
    2357                 :            : 
    2358                 :            :       /* Don't let it cross a call after scheduling if it doesn't
    2359                 :            :          already cross one.  */
    2360                 :      43715 :       if (REG_N_CALLS_CROSSED (regno) == 0)
    2361                 :            :         {
    2362                 :      38152 :           if (!deps->readonly && ref == USE && !DEBUG_INSN_P (insn))
    2363                 :       8257 :             deps->sched_before_next_call
    2364                 :       8257 :               = alloc_INSN_LIST (insn, deps->sched_before_next_call);
    2365                 :            :           else
    2366                 :      29895 :             add_dependence_list (insn, deps->last_function_call, 1,
    2367                 :            :                                  REG_DEP_ANTI, false);
    2368                 :            :         }
    2369                 :            :     }
    2370                 :   84041100 : }
    2371                 :            : 
    2372                 :            : /* Analyze a single SET, CLOBBER, PRE_DEC, POST_DEC, PRE_INC or POST_INC
    2373                 :            :    rtx, X, creating all dependencies generated by the write to the
    2374                 :            :    destination of X, and reads of everything mentioned.  */
    2375                 :            : 
    2376                 :            : static void
    2377                 :   45969400 : sched_analyze_1 (class deps_desc *deps, rtx x, rtx_insn *insn)
    2378                 :            : {
    2379                 :   45969400 :   rtx dest = XEXP (x, 0);
    2380                 :   45969400 :   enum rtx_code code = GET_CODE (x);
    2381                 :   45969400 :   bool cslr_p = can_start_lhs_rhs_p;
    2382                 :            : 
    2383                 :   45969400 :   can_start_lhs_rhs_p = false;
    2384                 :            : 
    2385                 :   45969400 :   gcc_assert (dest);
    2386                 :   45969400 :   if (dest == 0)
    2387                 :            :     return;
    2388                 :            : 
    2389                 :   45969400 :   if (cslr_p && sched_deps_info->start_lhs)
    2390                 :      18616 :     sched_deps_info->start_lhs (dest);
    2391                 :            : 
    2392                 :   45969400 :   if (GET_CODE (dest) == PARALLEL)
    2393                 :            :     {
    2394                 :       5890 :       int i;
    2395                 :            : 
    2396                 :      16456 :       for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
    2397                 :      10566 :         if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
    2398                 :      10566 :           sched_analyze_1 (deps,
    2399                 :            :                            gen_rtx_CLOBBER (VOIDmode,
    2400                 :            :                                             XEXP (XVECEXP (dest, 0, i), 0)),
    2401                 :            :                            insn);
    2402                 :            : 
    2403                 :       5890 :       if (cslr_p && sched_deps_info->finish_lhs)
    2404                 :          0 :         sched_deps_info->finish_lhs ();
    2405                 :            : 
    2406                 :       5890 :       if (code == SET)
    2407                 :            :         {
    2408                 :       5890 :           can_start_lhs_rhs_p = cslr_p;
    2409                 :            : 
    2410                 :       5890 :           sched_analyze_2 (deps, SET_SRC (x), insn);
    2411                 :            : 
    2412                 :       5890 :           can_start_lhs_rhs_p = false;
    2413                 :            :         }
    2414                 :            : 
    2415                 :       5890 :       return;
    2416                 :            :     }
    2417                 :            : 
    2418                 :   46001300 :   while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SUBREG
    2419                 :   46001300 :          || GET_CODE (dest) == ZERO_EXTRACT)
    2420                 :            :     {
    2421                 :      37814 :       if (GET_CODE (dest) == STRICT_LOW_PART
    2422                 :       9205 :          || GET_CODE (dest) == ZERO_EXTRACT
    2423                 :      38362 :          || read_modify_subreg_p (dest))
    2424                 :            :         {
    2425                 :            :           /* These both read and modify the result.  We must handle
    2426                 :            :              them as writes to get proper dependencies for following
    2427                 :            :              instructions.  We must handle them as reads to get proper
    2428                 :            :              dependencies from this to previous instructions.
    2429                 :            :              Thus we need to call sched_analyze_2.  */
    2430                 :            : 
    2431                 :      37384 :           sched_analyze_2 (deps, XEXP (dest, 0), insn);
    2432                 :            :         }
    2433                 :      37814 :       if (GET_CODE (dest) == ZERO_EXTRACT)
    2434                 :            :         {
    2435                 :            :           /* The second and third arguments are values read by this insn.  */
    2436                 :       8657 :           sched_analyze_2 (deps, XEXP (dest, 1), insn);
    2437                 :       8657 :           sched_analyze_2 (deps, XEXP (dest, 2), insn);
    2438                 :            :         }
    2439                 :      37814 :       dest = XEXP (dest, 0);
    2440                 :            :     }
    2441                 :            : 
    2442                 :   45963500 :   if (REG_P (dest))
    2443                 :            :     {
    2444                 :   32694200 :       int regno = REGNO (dest);
    2445                 :   32694200 :       machine_mode mode = GET_MODE (dest);
    2446                 :            : 
    2447                 :   32694200 :       sched_analyze_reg (deps, regno, mode, code, insn);
    2448                 :            : 
    2449                 :            : #ifdef STACK_REGS
    2450                 :            :       /* Treat all writes to a stack register as modifying the TOS.  */
    2451                 :   32694200 :       if (regno >= FIRST_STACK_REG && regno <= LAST_STACK_REG)
    2452                 :            :         {
    2453                 :            :           /* Avoid analyzing the same register twice.  */
    2454                 :     324239 :           if (regno != FIRST_STACK_REG)
    2455                 :     249499 :             sched_analyze_reg (deps, FIRST_STACK_REG, mode, code, insn);
    2456                 :            : 
    2457                 :     324239 :           add_to_hard_reg_set (&implicit_reg_pending_uses, mode,
    2458                 :            :                                FIRST_STACK_REG);
    2459                 :            :         }
    2460                 :            : #endif
    2461                 :            :     }
    2462                 :   13269300 :   else if (MEM_P (dest))
    2463                 :            :     {
    2464                 :            :       /* Writing memory.  */
    2465                 :    9149720 :       rtx t = dest;
    2466                 :            : 
    2467                 :    9149720 :       if (sched_deps_info->use_cselib)
    2468                 :            :         {
    2469                 :        252 :           machine_mode address_mode = get_address_mode (dest);
    2470                 :            : 
    2471                 :        252 :           t = shallow_copy_rtx (dest);
    2472                 :        252 :           cselib_lookup_from_insn (XEXP (t, 0), address_mode, 1,
    2473                 :        252 :                                    GET_MODE (t), insn);
    2474                 :        252 :           XEXP (t, 0)
    2475                 :        252 :             = cselib_subst_to_values_from_insn (XEXP (t, 0), GET_MODE (t),
    2476                 :            :                                                 insn);
    2477                 :            :         }
    2478                 :    9149720 :       t = canon_rtx (t);
    2479                 :            : 
    2480                 :            :       /* Pending lists can't get larger with a readonly context.  */
    2481                 :    9149720 :       if (!deps->readonly
    2482                 :    9147460 :           && ((deps->pending_read_list_length + deps->pending_write_list_length)
    2483                 :    9147460 :               >= param_max_pending_list_length))
    2484                 :            :         {
    2485                 :            :           /* Flush all pending reads and writes to prevent the pending lists
    2486                 :            :              from getting any larger.  Insn scheduling runs too slowly when
    2487                 :            :              these lists get long.  When compiling GCC with itself,
    2488                 :            :              this flush occurs 8 times for sparc, and 10 times for m88k using
    2489                 :            :              the default value of 32.  */
    2490                 :      17911 :           flush_pending_lists (deps, insn, false, true);
    2491                 :            :         }
    2492                 :            :       else
    2493                 :            :         {
    2494                 :    9131810 :           rtx_insn_list *pending;
    2495                 :    9131810 :           rtx_expr_list *pending_mem;
    2496                 :            : 
    2497                 :    9131810 :           pending = deps->pending_read_insns;
    2498                 :    9131810 :           pending_mem = deps->pending_read_mems;
    2499                 :   22463000 :           while (pending)
    2500                 :            :             {
    2501                 :   13331200 :               if (anti_dependence (pending_mem->element (), t)
    2502                 :   13331200 :                   && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
    2503                 :    2900630 :                 note_mem_dep (t, pending_mem->element (), pending->insn (),
    2504                 :            :                               DEP_ANTI);
    2505                 :            : 
    2506                 :   13331200 :               pending = pending->next ();
    2507                 :   35794100 :               pending_mem = pending_mem->next ();
    2508                 :            :             }
    2509                 :            : 
    2510                 :    9131810 :           pending = deps->pending_write_insns;
    2511                 :    9131810 :           pending_mem = deps->pending_write_mems;
    2512                 :   35010900 :           while (pending)
    2513                 :            :             {
    2514                 :   25879100 :               if (output_dependence (pending_mem->element (), t)
    2515                 :   25879100 :                   && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
    2516                 :    7187450 :                 note_mem_dep (t, pending_mem->element (),
    2517                 :            :                               pending->insn (),
    2518                 :            :                               DEP_OUTPUT);
    2519                 :            : 
    2520                 :   25879100 :               pending = pending->next ();
    2521                 :   60890000 :               pending_mem = pending_mem-> next ();
    2522                 :            :             }
    2523                 :            : 
    2524                 :    9131810 :           add_dependence_list (insn, deps->last_pending_memory_flush, 1,
    2525                 :            :                                REG_DEP_ANTI, true);
    2526                 :    9131810 :           add_dependence_list (insn, deps->pending_jump_insns, 1,
    2527                 :            :                                REG_DEP_CONTROL, true);
    2528                 :            : 
    2529                 :    9131810 :           if (!deps->readonly)
    2530                 :    9129550 :             add_insn_mem_dependence (deps, false, insn, dest);
    2531                 :            :         }
    2532                 :    9149720 :       sched_analyze_2 (deps, XEXP (dest, 0), insn);
    2533                 :            :     }
    2534                 :            : 
    2535                 :   45963500 :   if (cslr_p && sched_deps_info->finish_lhs)
    2536                 :      18616 :     sched_deps_info->finish_lhs ();
    2537                 :            : 
    2538                 :            :   /* Analyze reads.  */
    2539                 :   45963500 :   if (GET_CODE (x) == SET)
    2540                 :            :     {
    2541                 :   36359800 :       can_start_lhs_rhs_p = cslr_p;
    2542                 :            : 
    2543                 :   36359800 :       sched_analyze_2 (deps, SET_SRC (x), insn);
    2544                 :            : 
    2545                 :   36359800 :       can_start_lhs_rhs_p = false;
    2546                 :            :     }
    2547                 :            : }
    2548                 :            : 
    2549                 :            : /* Analyze the uses of memory and registers in rtx X in INSN.  */
    2550                 :            : static void
    2551                 :  207344000 : sched_analyze_2 (class deps_desc *deps, rtx x, rtx_insn *insn)
    2552                 :            : {
    2553                 :  207344000 :   int i;
    2554                 :  207344000 :   int j;
    2555                 :  207344000 :   enum rtx_code code;
    2556                 :  207344000 :   const char *fmt;
    2557                 :  207344000 :   bool cslr_p = can_start_lhs_rhs_p;
    2558                 :            : 
    2559                 :  207344000 :   can_start_lhs_rhs_p = false;
    2560                 :            : 
    2561                 :  207344000 :   gcc_assert (x);
    2562                 :  207344000 :   if (x == 0)
    2563                 :            :     return;
    2564                 :            : 
    2565                 :  207344000 :   if (cslr_p && sched_deps_info->start_rhs)
    2566                 :      18616 :     sched_deps_info->start_rhs (x);
    2567                 :            : 
    2568                 :  207344000 :   code = GET_CODE (x);
    2569                 :            : 
    2570                 :  207344000 :   switch (code)
    2571                 :            :     {
    2572                 :   53006200 :     CASE_CONST_ANY:
    2573                 :   53006200 :     case SYMBOL_REF:
    2574                 :   53006200 :     case CONST:
    2575                 :   53006200 :     case LABEL_REF:
    2576                 :            :       /* Ignore constants.  */
    2577                 :   53006200 :       if (cslr_p && sched_deps_info->finish_rhs)
    2578                 :       2596 :         sched_deps_info->finish_rhs ();
    2579                 :            : 
    2580                 :            :       return;
    2581                 :            : 
    2582                 :          0 :     case CC0:
    2583                 :          0 :       if (!HAVE_cc0)
    2584                 :          0 :         gcc_unreachable ();
    2585                 :            : 
    2586                 :            :       /* User of CC0 depends on immediately preceding insn.  */
    2587                 :            :       SCHED_GROUP_P (insn) = 1;
    2588                 :            :        /* Don't move CC0 setter to another block (it can set up the
    2589                 :            :         same flag for previous CC0 users which is safe).  */
    2590                 :            :       CANT_MOVE (prev_nonnote_insn (insn)) = 1;
    2591                 :            : 
    2592                 :            :       if (cslr_p && sched_deps_info->finish_rhs)
    2593                 :            :         sched_deps_info->finish_rhs ();
    2594                 :            : 
    2595                 :            :       return;
    2596                 :            : 
    2597                 :   50437100 :     case REG:
    2598                 :   50437100 :       {
    2599                 :   50437100 :         int regno = REGNO (x);
    2600                 :   50437100 :         machine_mode mode = GET_MODE (x);
    2601                 :            : 
    2602                 :   50437100 :         sched_analyze_reg (deps, regno, mode, USE, insn);
    2603                 :            : 
    2604                 :            : #ifdef STACK_REGS
    2605                 :            :       /* Treat all reads of a stack register as modifying the TOS.  */
    2606                 :   50437100 :       if (regno >= FIRST_STACK_REG && regno <= LAST_STACK_REG)
    2607                 :            :         {
    2608                 :            :           /* Avoid analyzing the same register twice.  */
    2609                 :     382586 :           if (regno != FIRST_STACK_REG)
    2610                 :     277656 :             sched_analyze_reg (deps, FIRST_STACK_REG, mode, USE, insn);
    2611                 :     382586 :           sched_analyze_reg (deps, FIRST_STACK_REG, mode, SET, insn);
    2612                 :            :         }
    2613                 :            : #endif
    2614                 :            : 
    2615                 :   50437100 :         if (cslr_p && sched_deps_info->finish_rhs)
    2616                 :       8463 :           sched_deps_info->finish_rhs ();
    2617                 :            : 
    2618                 :            :         return;
    2619                 :            :       }
    2620                 :            : 
    2621                 :   12424300 :     case MEM:
    2622                 :   12424300 :       {
    2623                 :            :         /* Reading memory.  */
    2624                 :   12424300 :         rtx_insn_list *u;
    2625                 :   12424300 :         rtx_insn_list *pending;
    2626                 :   12424300 :         rtx_expr_list *pending_mem;
    2627                 :   12424300 :         rtx t = x;
    2628                 :            : 
    2629                 :   12424300 :         if (sched_deps_info->use_cselib)
    2630                 :            :           {
    2631                 :        344 :             machine_mode address_mode = get_address_mode (t);
    2632                 :            : 
    2633                 :        344 :             t = shallow_copy_rtx (t);
    2634                 :        344 :             cselib_lookup_from_insn (XEXP (t, 0), address_mode, 1,
    2635                 :        344 :                                      GET_MODE (t), insn);
    2636                 :        344 :             XEXP (t, 0)
    2637                 :        344 :               = cselib_subst_to_values_from_insn (XEXP (t, 0), GET_MODE (t),
    2638                 :            :                                                   insn);
    2639                 :            :           }
    2640                 :            : 
    2641                 :   12424300 :         if (!DEBUG_INSN_P (insn))
    2642                 :            :           {
    2643                 :   11430500 :             t = canon_rtx (t);
    2644                 :   11430500 :             pending = deps->pending_read_insns;
    2645                 :   11430500 :             pending_mem = deps->pending_read_mems;
    2646                 :   32182600 :             while (pending)
    2647                 :            :               {
    2648                 :   20752000 :                 if (read_dependence (pending_mem->element (), t)
    2649                 :   21143800 :                     && ! sched_insns_conditions_mutex_p (insn,
    2650                 :     391767 :                                                          pending->insn ()))
    2651                 :     391767 :                   note_mem_dep (t, pending_mem->element (),
    2652                 :            :                                 pending->insn (),
    2653                 :            :                                 DEP_ANTI);
    2654                 :            : 
    2655                 :   20752000 :                 pending = pending->next ();
    2656                 :   52934600 :                 pending_mem = pending_mem->next ();
    2657                 :            :               }
    2658                 :            : 
    2659                 :   11430500 :             pending = deps->pending_write_insns;
    2660                 :   11430500 :             pending_mem = deps->pending_write_mems;
    2661                 :   29263600 :             while (pending)
    2662                 :            :               {
    2663                 :   17833100 :                 if (true_dependence (pending_mem->element (), VOIDmode, t)
    2664                 :   22399100 :                     && ! sched_insns_conditions_mutex_p (insn,
    2665                 :    4566040 :                                                          pending->insn ()))
    2666                 :    4566040 :                   note_mem_dep (t, pending_mem->element (),
    2667                 :            :                                 pending->insn (),
    2668                 :            :                                 sched_deps_info->generate_spec_deps
    2669                 :    4566040 :                                 ? BEGIN_DATA | DEP_TRUE : DEP_TRUE);
    2670                 :            : 
    2671                 :   17833100 :                 pending = pending->next ();
    2672                 :   47096800 :                 pending_mem = pending_mem->next ();
    2673                 :            :               }
    2674                 :            : 
    2675                 :   14916800 :             for (u = deps->last_pending_memory_flush; u; u = u->next ())
    2676                 :    3486170 :               add_dependence (insn, u->insn (), REG_DEP_ANTI);
    2677                 :            : 
    2678                 :   11431100 :             for (u = deps->pending_jump_insns; u; u = u->next ())
    2679                 :      14788 :               if (deps_may_trap_p (x))
    2680                 :            :                 {
    2681                 :      14362 :                   if ((sched_deps_info->generate_spec_deps)
    2682                 :      14362 :                       && sel_sched_p () && (spec_info->mask & BEGIN_CONTROL))
    2683                 :            :                     {
    2684                 :          0 :                       ds_t ds = set_dep_weak (DEP_ANTI, BEGIN_CONTROL,
    2685                 :            :                                               MAX_DEP_WEAK);
    2686                 :            :                       
    2687                 :      14788 :                       note_dep (u->insn (), ds);
    2688                 :            :                     }
    2689                 :            :                   else
    2690                 :      14362 :                     add_dependence (insn, u->insn (), REG_DEP_CONTROL);
    2691                 :            :                 }
    2692                 :            :           }
    2693                 :            : 
    2694                 :            :         /* Always add these dependencies to pending_reads, since
    2695                 :            :            this insn may be followed by a write.  */
    2696                 :   12424300 :         if (!deps->readonly)
    2697                 :            :           {
    2698                 :   12419600 :             if ((deps->pending_read_list_length
    2699                 :   12419600 :                  + deps->pending_write_list_length)
    2700                 :   12419600 :                 >= param_max_pending_list_length
    2701                 :      16921 :                 && !DEBUG_INSN_P (insn))
    2702                 :      14922 :               flush_pending_lists (deps, insn, true, true);
    2703                 :   12419600 :             add_insn_mem_dependence (deps, true, insn, x);
    2704                 :            :           }
    2705                 :            : 
    2706                 :   12424300 :         sched_analyze_2 (deps, XEXP (x, 0), insn);
    2707                 :            : 
    2708                 :   12424300 :         if (cslr_p && sched_deps_info->finish_rhs)
    2709                 :       1666 :           sched_deps_info->finish_rhs ();
    2710                 :            : 
    2711                 :            :         return;
    2712                 :            :       }
    2713                 :            : 
    2714                 :            :     /* Force pending stores to memory in case a trap handler needs them.
    2715                 :            :        Also force pending loads from memory; loads and stores can segfault
    2716                 :            :        and the signal handler won't be triggered if the trap insn was moved
    2717                 :            :        above load or store insn.  */
    2718                 :       2964 :     case TRAP_IF:
    2719                 :       2964 :       flush_pending_lists (deps, insn, true, true);
    2720                 :       2964 :       break;
    2721                 :            : 
    2722                 :       1594 :     case PREFETCH:
    2723                 :       1594 :       if (PREFETCH_SCHEDULE_BARRIER_P (x))
    2724                 :          0 :         reg_pending_barrier = TRUE_BARRIER;
    2725                 :            :       /* Prefetch insn contains addresses only.  So if the prefetch
    2726                 :            :          address has no registers, there will be no dependencies on
    2727                 :            :          the prefetch insn.  This is wrong with result code
    2728                 :            :          correctness point of view as such prefetch can be moved below
    2729                 :            :          a jump insn which usually generates MOVE_BARRIER preventing
    2730                 :            :          to move insns containing registers or memories through the
    2731                 :            :          barrier.  It is also wrong with generated code performance
    2732                 :            :          point of view as prefetch withouth dependecies will have a
    2733                 :            :          tendency to be issued later instead of earlier.  It is hard
    2734                 :            :          to generate accurate dependencies for prefetch insns as
    2735                 :            :          prefetch has only the start address but it is better to have
    2736                 :            :          something than nothing.  */
    2737                 :       1594 :       if (!deps->readonly)
    2738                 :            :         {
    2739                 :       1607 :           rtx x = gen_rtx_MEM (Pmode, XEXP (PATTERN (insn), 0));
    2740                 :       1559 :           if (sched_deps_info->use_cselib)
    2741                 :          2 :             cselib_lookup_from_insn (x, Pmode, true, VOIDmode, insn);
    2742                 :       1559 :           add_insn_mem_dependence (deps, true, insn, x);
    2743                 :            :         }
    2744                 :            :       break;
    2745                 :            : 
    2746                 :     497847 :     case UNSPEC_VOLATILE:
    2747                 :     497847 :       flush_pending_lists (deps, insn, true, true);
    2748                 :            :       /* FALLTHRU */
    2749                 :            : 
    2750                 :     591112 :     case ASM_OPERANDS:
    2751                 :     591112 :     case ASM_INPUT:
    2752                 :     591112 :       {
    2753                 :            :         /* Traditional and volatile asm instructions must be considered to use
    2754                 :            :            and clobber all hard registers, all pseudo-registers and all of
    2755                 :            :            memory.  So must TRAP_IF and UNSPEC_VOLATILE operations.
    2756                 :            : 
    2757                 :            :            Consider for instance a volatile asm that changes the fpu rounding
    2758                 :            :            mode.  An insn should not be moved across this even if it only uses
    2759                 :            :            pseudo-regs because it might give an incorrectly rounded result.  */
    2760                 :      91349 :         if ((code != ASM_OPERANDS || MEM_VOLATILE_P (x))
    2761                 :     628510 :             && !DEBUG_INSN_P (insn))
    2762                 :     537161 :           reg_pending_barrier = TRUE_BARRIER;
    2763                 :            : 
    2764                 :            :         /* For all ASM_OPERANDS, we must traverse the vector of input operands.
    2765                 :            :            We cannot just fall through here since then we would be confused
    2766                 :            :            by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
    2767                 :            :            traditional asms unlike their normal usage.  */
    2768                 :            : 
    2769                 :     591112 :         if (code == ASM_OPERANDS)
    2770                 :            :           {
    2771                 :     180712 :             for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
    2772                 :      89363 :               sched_analyze_2 (deps, ASM_OPERANDS_INPUT (x, j), insn);
    2773                 :            : 
    2774                 :      91349 :             if (cslr_p && sched_deps_info->finish_rhs)
    2775                 :          0 :               sched_deps_info->finish_rhs ();
    2776                 :            : 
    2777                 :      91349 :             return;
    2778                 :            :           }
    2779                 :            :         break;
    2780                 :            :       }
    2781                 :            : 
    2782                 :    3797260 :     case PRE_DEC:
    2783                 :    3797260 :     case POST_DEC:
    2784                 :    3797260 :     case PRE_INC:
    2785                 :    3797260 :     case POST_INC:
    2786                 :            :       /* These both read and modify the result.  We must handle them as writes
    2787                 :            :          to get proper dependencies for following instructions.  We must handle
    2788                 :            :          them as reads to get proper dependencies from this to previous
    2789                 :            :          instructions.  Thus we need to pass them to both sched_analyze_1
    2790                 :            :          and sched_analyze_2.  We must call sched_analyze_2 first in order
    2791                 :            :          to get the proper antecedent for the read.  */
    2792                 :    3797260 :       sched_analyze_2 (deps, XEXP (x, 0), insn);
    2793                 :    3797260 :       sched_analyze_1 (deps, x, insn);
    2794                 :            : 
    2795                 :    3797260 :       if (cslr_p && sched_deps_info->finish_rhs)
    2796                 :          0 :         sched_deps_info->finish_rhs ();
    2797                 :            : 
    2798                 :            :       return;
    2799                 :            : 
    2800                 :      49368 :     case POST_MODIFY:
    2801                 :      49368 :     case PRE_MODIFY:
    2802                 :            :       /* op0 = op0 + op1 */
    2803                 :      49368 :       sched_analyze_2 (deps, XEXP (x, 0), insn);
    2804                 :      49368 :       sched_analyze_2 (deps, XEXP (x, 1), insn);
    2805                 :      49368 :       sched_analyze_1 (deps, x, insn);
    2806                 :            : 
    2807                 :      49368 :       if (cslr_p && sched_deps_info->finish_rhs)
    2808                 :          0 :         sched_deps_info->finish_rhs ();
    2809                 :            : 
    2810                 :            :       return;
    2811                 :            : 
    2812                 :            :     default:
    2813                 :            :       break;
    2814                 :            :     }
    2815                 :            : 
    2816                 :            :   /* Other cases: walk the insn.  */
    2817                 :   87538100 :   fmt = GET_RTX_FORMAT (code);
    2818                 :  223197000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2819                 :            :     {
    2820                 :  135659000 :       if (fmt[i] == 'e')
    2821                 :  107743000 :         sched_analyze_2 (deps, XEXP (x, i), insn);
    2822                 :   27916300 :       else if (fmt[i] == 'E')
    2823                 :    2487530 :         for (j = 0; j < XVECLEN (x, i); j++)
    2824                 :    1536210 :           sched_analyze_2 (deps, XVECEXP (x, i, j), insn);
    2825                 :            :     }
    2826                 :            : 
    2827                 :   87538100 :   if (cslr_p && sched_deps_info->finish_rhs)
    2828                 :       5891 :     sched_deps_info->finish_rhs ();
    2829                 :            : }
    2830                 :            : 
    2831                 :            : /* Try to group two fusible insns together to prevent scheduler
    2832                 :            :    from scheduling them apart.  */
    2833                 :            : 
    2834                 :            : static void
    2835                 :   66846200 : sched_macro_fuse_insns (rtx_insn *insn)
    2836                 :            : {
    2837                 :   66846200 :   rtx_insn *prev;
    2838                 :            :   /* No target hook would return true for debug insn as any of the
    2839                 :            :      hook operand, and with very large sequences of only debug insns
    2840                 :            :      where on each we call sched_macro_fuse_insns it has quadratic
    2841                 :            :      compile time complexity.  */
    2842                 :   66846200 :   if (DEBUG_INSN_P (insn))
    2843                 :            :     return;
    2844                 :   39092000 :   prev = prev_nonnote_nondebug_insn (insn);
    2845                 :   39092000 :   if (!prev)
    2846                 :            :     return;
    2847                 :            : 
    2848                 :   38481400 :   if (any_condjump_p (insn))
    2849                 :            :     {
    2850                 :    3031740 :       unsigned int condreg1, condreg2;
    2851                 :    3031740 :       rtx cc_reg_1;
    2852                 :    3031740 :       if (targetm.fixed_condition_code_regs (&condreg1, &condreg2))
    2853                 :            :         {
    2854                 :    3031740 :           cc_reg_1 = gen_rtx_REG (CCmode, condreg1);
    2855                 :    3031740 :           if (reg_referenced_p (cc_reg_1, PATTERN (insn))
    2856                 :    3031740 :               && modified_in_p (cc_reg_1, prev))
    2857                 :            :             {
    2858                 :    2946940 :               if (targetm.sched.macro_fusion_pair_p (prev, insn))
    2859                 :    2374340 :                 SCHED_GROUP_P (insn) = 1;
    2860                 :    2946940 :               return;
    2861                 :            :             }
    2862                 :            :         }
    2863                 :            :     }
    2864                 :            : 
    2865                 :   35534500 :   if (single_set (insn) && single_set (prev))
    2866                 :            :     {
    2867                 :   27195100 :       if (targetm.sched.macro_fusion_pair_p (prev, insn))
    2868                 :          0 :         SCHED_GROUP_P (insn) = 1;
    2869                 :            :     }
    2870                 :            : }
    2871                 :            : 
    2872                 :            : /* Get the implicit reg pending clobbers for INSN and save them in TEMP.  */
    2873                 :            : void
    2874                 :      33212 : get_implicit_reg_pending_clobbers (HARD_REG_SET *temp, rtx_insn *insn)
    2875                 :            : {
    2876                 :      33212 :   extract_insn (insn);
    2877                 :      33212 :   preprocess_constraints (insn);
    2878                 :      33212 :   alternative_mask preferred = get_preferred_alternatives (insn);
    2879                 :      33212 :   ira_implicitly_set_insn_hard_regs (temp, preferred);
    2880                 :      66424 :   *temp &= ~ira_no_alloc_regs;
    2881                 :      33212 : }
    2882                 :            : 
    2883                 :            : /* Analyze an INSN with pattern X to find all dependencies.  */
    2884                 :            : static void
    2885                 :   67038100 : sched_analyze_insn (class deps_desc *deps, rtx x, rtx_insn *insn)
    2886                 :            : {
    2887                 :   67038100 :   RTX_CODE code = GET_CODE (x);
    2888                 :   67038100 :   rtx link;
    2889                 :   67038100 :   unsigned i;
    2890                 :   67038100 :   reg_set_iterator rsi;
    2891                 :            : 
    2892                 :   67038100 :   if (! reload_completed)
    2893                 :            :     {
    2894                 :      31385 :       HARD_REG_SET temp;
    2895                 :      31385 :       get_implicit_reg_pending_clobbers (&temp, insn);
    2896                 :      62770 :       implicit_reg_pending_clobbers |= temp;
    2897                 :            :     }
    2898                 :            : 
    2899                 :  134076000 :   can_start_lhs_rhs_p = (NONJUMP_INSN_P (insn)
    2900                 :   67038100 :                          && code == SET);
    2901                 :            : 
    2902                 :            :   /* Group compare and branch insns for macro-fusion.  */
    2903                 :   67038100 :   if (!deps->readonly
    2904                 :   67006100 :       && targetm.sched.macro_fusion_p
    2905                 :  134044000 :       && targetm.sched.macro_fusion_p ())
    2906                 :   66846200 :     sched_macro_fuse_insns (insn);
    2907                 :            : 
    2908                 :   67038100 :   if (may_trap_p (x))
    2909                 :            :     /* Avoid moving trapping instructions across function calls that might
    2910                 :            :        not always return.  */
    2911                 :    5757830 :     add_dependence_list (insn, deps->last_function_call_may_noreturn,
    2912                 :            :                          1, REG_DEP_ANTI, true);
    2913                 :            : 
    2914                 :            :   /* We must avoid creating a situation in which two successors of the
    2915                 :            :      current block have different unwind info after scheduling.  If at any
    2916                 :            :      point the two paths re-join this leads to incorrect unwind info.  */
    2917                 :            :   /* ??? There are certain situations involving a forced frame pointer in
    2918                 :            :      which, with extra effort, we could fix up the unwind info at a later
    2919                 :            :      CFG join.  However, it seems better to notice these cases earlier
    2920                 :            :      during prologue generation and avoid marking the frame pointer setup
    2921                 :            :      as frame-related at all.  */
    2922                 :   67038100 :   if (RTX_FRAME_RELATED_P (insn))
    2923                 :            :     {
    2924                 :            :       /* Make sure prologue insn is scheduled before next jump.  */
    2925                 :    2604920 :       deps->sched_before_next_jump
    2926                 :    2604920 :         = alloc_INSN_LIST (insn, deps->sched_before_next_jump);
    2927                 :            : 
    2928                 :            :       /* Make sure epilogue insn is scheduled after preceding jumps.  */
    2929                 :    2604920 :       add_dependence_list (insn, deps->last_pending_memory_flush, 1,
    2930                 :            :                            REG_DEP_ANTI, true);
    2931                 :    2604920 :       add_dependence_list (insn, deps->pending_jump_insns, 1, REG_DEP_ANTI,
    2932                 :            :                            true);
    2933                 :            :     }
    2934                 :            : 
    2935                 :   67038100 :   if (code == COND_EXEC)
    2936                 :            :     {
    2937                 :          0 :       sched_analyze_2 (deps, COND_EXEC_TEST (x), insn);
    2938                 :            : 
    2939                 :            :       /* ??? Should be recording conditions so we reduce the number of
    2940                 :            :          false dependencies.  */
    2941                 :          0 :       x = COND_EXEC_CODE (x);
    2942                 :          0 :       code = GET_CODE (x);
    2943                 :            :     }
    2944                 :   67038100 :   if (code == SET || code == CLOBBER)
    2945                 :            :     {
    2946                 :   30914600 :       sched_analyze_1 (deps, x, insn);
    2947                 :            : 
    2948                 :            :       /* Bare clobber insns are used for letting life analysis, reg-stack
    2949                 :            :          and others know that a value is dead.  Depend on the last call
    2950                 :            :          instruction so that reg-stack won't get confused.  */
    2951                 :   30914600 :       if (code == CLOBBER)
    2952                 :      62629 :         add_dependence_list (insn, deps->last_function_call, 1,
    2953                 :            :                              REG_DEP_OUTPUT, true);
    2954                 :            :     }
    2955                 :   36123500 :   else if (code == PARALLEL)
    2956                 :            :     {
    2957                 :   16595000 :       for (i = XVECLEN (x, 0); i--;)
    2958                 :            :         {
    2959                 :   11485400 :           rtx sub = XVECEXP (x, 0, i);
    2960                 :   11485400 :           code = GET_CODE (sub);
    2961                 :            : 
    2962                 :   11485400 :           if (code == COND_EXEC)
    2963                 :            :             {
    2964                 :          0 :               sched_analyze_2 (deps, COND_EXEC_TEST (sub), insn);
    2965                 :          0 :               sub = COND_EXEC_CODE (sub);
    2966                 :          0 :               code = GET_CODE (sub);
    2967                 :            :             }
    2968                 :   11485400 :           else if (code == SET || code == CLOBBER)
    2969                 :   11088900 :             sched_analyze_1 (deps, sub, insn);
    2970                 :            :           else
    2971                 :     396549 :             sched_analyze_2 (deps, sub, insn);
    2972                 :            :         }
    2973                 :            :     }
    2974                 :            :   else
    2975                 :   31014000 :     sched_analyze_2 (deps, x, insn);
    2976                 :            : 
    2977                 :            :   /* Mark registers CLOBBERED or used by called function.  */
    2978                 :   67038100 :   if (CALL_P (insn))
    2979                 :            :     {
    2980                 :    7855080 :       for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
    2981                 :            :         {
    2982                 :    4804480 :           if (GET_CODE (XEXP (link, 0)) == CLOBBER)
    2983                 :     108756 :             sched_analyze_1 (deps, XEXP (link, 0), insn);
    2984                 :    4695720 :           else if (GET_CODE (XEXP (link, 0)) != SET)
    2985                 :    4674040 :             sched_analyze_2 (deps, XEXP (link, 0), insn);
    2986                 :            :         }
    2987                 :            :       /* Don't schedule anything after a tail call, tail call needs
    2988                 :            :          to use at least all call-saved registers.  */
    2989                 :    3050610 :       if (SIBLING_CALL_P (insn))
    2990                 :      89619 :         reg_pending_barrier = TRUE_BARRIER;
    2991                 :    2960990 :       else if (find_reg_note (insn, REG_SETJMP, NULL))
    2992                 :        434 :         reg_pending_barrier = MOVE_BARRIER;
    2993                 :            :     }
    2994                 :            : 
    2995                 :   67038100 :   if (JUMP_P (insn))
    2996                 :            :     {
    2997                 :    4820460 :       rtx_insn *next = next_nonnote_nondebug_insn (insn);
    2998                 :            :       /* ??? For tablejumps, the barrier may appear not immediately after
    2999                 :            :          the jump, but after a label and a jump_table_data insn.  */
    3000                 :    4820450 :       if (next && LABEL_P (next) && NEXT_INSN (next)
    3001                 :    5507760 :           && JUMP_TABLE_DATA_P (NEXT_INSN (next)))
    3002                 :       1090 :         next = NEXT_INSN (NEXT_INSN (next));
    3003                 :    4820460 :       if (next && BARRIER_P (next))
    3004                 :    1786050 :         reg_pending_barrier = MOVE_BARRIER;
    3005                 :            :       else
    3006                 :            :         {
    3007                 :    3034410 :           rtx_insn_list *pending;
    3008                 :    3034410 :           rtx_expr_list *pending_mem;
    3009                 :            : 
    3010                 :    3034410 :           if (sched_deps_info->compute_jump_reg_dependencies)
    3011                 :            :             {
    3012                 :    3032940 :               (*sched_deps_info->compute_jump_reg_dependencies)
    3013                 :    3032940 :                 (insn, reg_pending_control_uses);
    3014                 :            : 
    3015                 :            :               /* Make latency of jump equal to 0 by using anti-dependence.  */
    3016                 :    3033230 :               EXECUTE_IF_SET_IN_REG_SET (reg_pending_control_uses, 0, i, rsi)
    3017                 :            :                 {
    3018                 :        286 :                   struct deps_reg *reg_last = &deps->reg_last[i];
    3019                 :        286 :                   add_dependence_list (insn, reg_last->sets, 0, REG_DEP_ANTI,
    3020                 :            :                                        false);
    3021                 :        286 :                   add_dependence_list (insn, reg_last->implicit_sets,
    3022                 :            :                                        0, REG_DEP_ANTI, false);
    3023                 :        286 :                   add_dependence_list (insn, reg_last->clobbers, 0,
    3024                 :            :                                        REG_DEP_ANTI, false);
    3025                 :            :                 }
    3026                 :            :             }
    3027                 :            : 
    3028                 :            :           /* All memory writes and volatile reads must happen before the
    3029                 :            :              jump.  Non-volatile reads must happen before the jump iff
    3030                 :            :              the result is needed by the above register used mask.  */
    3031                 :            : 
    3032                 :    3034410 :           pending = deps->pending_write_insns;
    3033                 :    3034410 :           pending_mem = deps->pending_write_mems;
    3034                 :    4964170 :           while (pending)
    3035                 :            :             {
    3036                 :    1929760 :               if (! sched_insns_conditions_mutex_p (insn, pending->insn ()))
    3037                 :    1929760 :                 add_dependence (insn, pending->insn (),
    3038                 :            :                                 REG_DEP_OUTPUT);
    3039                 :    1929760 :               pending = pending->next ();
    3040                 :    6893940 :               pending_mem = pending_mem->next ();
    3041                 :            :             }
    3042                 :            : 
    3043                 :    3034410 :           pending = deps->pending_read_insns;
    3044                 :    3034410 :           pending_mem = deps->pending_read_mems;
    3045                 :    7022020 :           while (pending)
    3046                 :            :             {
    3047                 :    3987620 :               if (MEM_VOLATILE_P (pending_mem->element ())
    3048                 :    3987620 :                   && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
    3049                 :     290880 :                 add_dependence (insn, pending->insn (),
    3050                 :            :                                 REG_DEP_OUTPUT);
    3051                 :    3987620 :               pending = pending->next ();
    3052                 :   11009600 :               pending_mem = pending_mem->next ();
    3053                 :            :             }
    3054                 :            : 
    3055                 :    3034410 :           add_dependence_list (insn, deps->last_pending_memory_flush, 1,
    3056                 :            :                                REG_DEP_ANTI, true);
    3057                 :    3034410 :           add_dependence_list (insn, deps->pending_jump_insns, 1,
    3058                 :            :                                REG_DEP_ANTI, true);
    3059                 :            :         }
    3060                 :            :     }
    3061                 :            : 
    3062                 :            :   /* If this instruction can throw an exception, then moving it changes
    3063                 :            :      where block boundaries fall.  This is mighty confusing elsewhere.
    3064                 :            :      Therefore, prevent such an instruction from being moved.  Same for
    3065                 :            :      non-jump instructions that define block boundaries.
    3066                 :            :      ??? Unclear whether this is still necessary in EBB mode.  If not,
    3067                 :            :      add_branch_dependences should be adjusted for RGN mode instead.  */
    3068                 :    7871070 :   if (((CALL_P (insn) || JUMP_P (insn)) && can_throw_internal (insn))
    3069                 :   74552700 :       || (NONJUMP_INSN_P (insn) && control_flow_insn_p (insn)))
    3070                 :     439528 :     reg_pending_barrier = MOVE_BARRIER;
    3071                 :            : 
    3072                 :   67038100 :   if (sched_pressure != SCHED_PRESSURE_NONE)
    3073                 :            :     {
    3074                 :       7777 :       setup_insn_reg_uses (deps, insn);
    3075                 :       7777 :       init_insn_reg_pressure_info (insn);
    3076                 :            :     }
    3077                 :            : 
    3078                 :            :   /* Add register dependencies for insn.  */
    3079                 :   67038100 :   if (DEBUG_INSN_P (insn))
    3080                 :            :     {
    3081                 :   27755800 :       rtx_insn *prev = deps->last_debug_insn;
    3082                 :   27755800 :       rtx_insn_list *u;
    3083                 :            : 
    3084                 :   27755800 :       if (!deps->readonly)
    3085                 :   27754700 :         deps->last_debug_insn = insn;
    3086                 :            : 
    3087                 :   27755800 :       if (prev)
    3088                 :   25575600 :         add_dependence (insn, prev, REG_DEP_ANTI);
    3089                 :            : 
    3090                 :   27755800 :       add_dependence_list (insn, deps->last_function_call, 1,
    3091                 :            :                            REG_DEP_ANTI, false);
    3092                 :            : 
    3093                 :   27755800 :       if (!sel_sched_p ())
    3094                 :   33032000 :         for (u = deps->last_pending_memory_flush; u; u = u->next ())
    3095                 :    5277560 :           add_dependence (insn, u->insn (), REG_DEP_ANTI);
    3096                 :            : 
    3097                 :   33156000 :       EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
    3098                 :            :         {
    3099                 :    5400200 :           struct deps_reg *reg_last = &deps->reg_last[i];
    3100                 :    5400200 :           add_dependence_list (insn, reg_last->sets, 1, REG_DEP_ANTI, false);
    3101                 :            :           /* There's no point in making REG_DEP_CONTROL dependencies for
    3102                 :            :              debug insns.  */
    3103                 :    5400200 :           add_dependence_list (insn, reg_last->clobbers, 1, REG_DEP_ANTI,
    3104                 :            :                                false);
    3105                 :            : 
    3106                 :    5400200 :           if (!deps->readonly)
    3107                 :    5400200 :             reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
    3108                 :            :         }
    3109                 :   27755800 :       CLEAR_REG_SET (reg_pending_uses);
    3110                 :            : 
    3111                 :            :       /* Quite often, a debug insn will refer to stuff in the
    3112                 :            :          previous instruction, but the reason we want this
    3113                 :            :          dependency here is to make sure the scheduler doesn't
    3114                 :            :          gratuitously move a debug insn ahead.  This could dirty
    3115                 :            :          DF flags and cause additional analysis that wouldn't have
    3116                 :            :          occurred in compilation without debug insns, and such
    3117                 :            :          additional analysis can modify the generated code.  */
    3118                 :   27755800 :       prev = PREV_INSN (insn);
    3119                 :            : 
    3120                 :   27755800 :       if (prev && NONDEBUG_INSN_P (prev))
    3121                 :    2263650 :         add_dependence (insn, prev, REG_DEP_ANTI);
    3122                 :            :     }
    3123                 :            :   else
    3124                 :            :     {
    3125                 :   39282400 :       regset_head set_or_clobbered;
    3126                 :            : 
    3127                 :   83247900 :       EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
    3128                 :            :         {
    3129                 :   43965500 :           struct deps_reg *reg_last = &deps->reg_last[i];
    3130                 :   43965500 :           add_dependence_list (insn, reg_last->sets, 0, REG_DEP_TRUE, false);
    3131                 :   43965500 :           add_dependence_list (insn, reg_last->implicit_sets, 0, REG_DEP_ANTI,
    3132                 :            :                                false);
    3133                 :   43965500 :           add_dependence_list (insn, reg_last->clobbers, 0, REG_DEP_TRUE,
    3134                 :            :                                false);
    3135                 :            : 
    3136                 :   43965500 :           if (!deps->readonly)
    3137                 :            :             {
    3138                 :   43954200 :               reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
    3139                 :   43954200 :               reg_last->uses_length++;
    3140                 :            :             }
    3141                 :            :         }
    3142                 :            : 
    3143                 : 3024740000 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3144                 : 2985460000 :         if (TEST_HARD_REG_BIT (implicit_reg_pending_uses, i))
    3145                 :            :           {
    3146                 :    9784250 :             struct deps_reg *reg_last = &deps->reg_last[i];
    3147                 :    9784250 :             add_dependence_list (insn, reg_last->sets, 0, REG_DEP_TRUE, false);
    3148                 :    9784250 :             add_dependence_list (insn, reg_last->implicit_sets, 0,
    3149                 :            :                                  REG_DEP_ANTI, false);
    3150                 :    9784250 :             add_dependence_list (insn, reg_last->clobbers, 0, REG_DEP_TRUE,
    3151                 :            :                                  false);
    3152                 :            : 
    3153                 :    9784250 :             if (!deps->readonly)
    3154                 :            :               {
    3155                 :    9782590 :                 reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
    3156                 :    9782590 :                 reg_last->uses_length++;
    3157                 :            :               }
    3158                 :            :           }
    3159                 :            : 
    3160                 :   39282400 :       if (targetm.sched.exposed_pipeline)
    3161                 :            :         {
    3162                 :          0 :           INIT_REG_SET (&set_or_clobbered);
    3163                 :          0 :           bitmap_ior (&set_or_clobbered, reg_pending_clobbers,
    3164                 :            :                       reg_pending_sets);
    3165                 :          0 :           EXECUTE_IF_SET_IN_REG_SET (&set_or_clobbered, 0, i, rsi)
    3166                 :            :             {
    3167                 :          0 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3168                 :          0 :               rtx list;
    3169                 :          0 :               for (list = reg_last->uses; list; list = XEXP (list, 1))
    3170                 :            :                 {
    3171                 :          0 :                   rtx other = XEXP (list, 0);
    3172                 :          0 :                   if (INSN_CACHED_COND (other) != const_true_rtx
    3173                 :          0 :                       && refers_to_regno_p (i, INSN_CACHED_COND (other)))
    3174                 :          0 :                     INSN_CACHED_COND (other) = const_true_rtx;
    3175                 :            :                 }
    3176                 :            :             }
    3177                 :            :         }
    3178                 :            : 
    3179                 :            :       /* If the current insn is conditional, we can't free any
    3180                 :            :          of the lists.  */
    3181                 :   39282400 :       if (sched_has_condition_p (insn))
    3182                 :            :         {
    3183                 :    3034240 :           EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i, rsi)
    3184                 :            :             {
    3185                 :          0 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3186                 :          0 :               add_dependence_list (insn, reg_last->sets, 0, REG_DEP_OUTPUT,
    3187                 :            :                                    false);
    3188                 :          0 :               add_dependence_list (insn, reg_last->implicit_sets, 0,
    3189                 :            :                                    REG_DEP_ANTI, false);
    3190                 :          0 :               add_dependence_list (insn, reg_last->uses, 0, REG_DEP_ANTI,
    3191                 :            :                                    false);
    3192                 :          0 :               add_dependence_list (insn, reg_last->control_uses, 0,
    3193                 :            :                                    REG_DEP_CONTROL, false);
    3194                 :            : 
    3195                 :          0 :               if (!deps->readonly)
    3196                 :            :                 {
    3197                 :          0 :                   reg_last->clobbers
    3198                 :          0 :                     = alloc_INSN_LIST (insn, reg_last->clobbers);
    3199                 :          0 :                   reg_last->clobbers_length++;
    3200                 :            :                 }
    3201                 :            :             }
    3202                 :    3034240 :           EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i, rsi)
    3203                 :            :             {
    3204                 :          0 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3205                 :          0 :               add_dependence_list (insn, reg_last->sets, 0, REG_DEP_OUTPUT,
    3206                 :            :                                    false);
    3207                 :          0 :               add_dependence_list (insn, reg_last->implicit_sets, 0,
    3208                 :            :                                    REG_DEP_ANTI, false);
    3209                 :          0 :               add_dependence_list (insn, reg_last->clobbers, 0, REG_DEP_OUTPUT,
    3210                 :            :                                    false);
    3211                 :          0 :               add_dependence_list (insn, reg_last->uses, 0, REG_DEP_ANTI,
    3212                 :            :                                    false);
    3213                 :          0 :               add_dependence_list (insn, reg_last->control_uses, 0,
    3214                 :            :                                    REG_DEP_CONTROL, false);
    3215                 :            : 
    3216                 :          0 :               if (!deps->readonly)
    3217                 :          0 :                 reg_last->sets = alloc_INSN_LIST (insn, reg_last->sets);
    3218                 :            :             }
    3219                 :            :         }
    3220                 :            :       else
    3221                 :            :         {
    3222                 :  245593000 :           EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i, rsi)
    3223                 :            :             {
    3224                 :  209345000 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3225                 :  209345000 :               if (reg_last->uses_length >= param_max_pending_list_length
    3226                 :  209343000 :                   || reg_last->clobbers_length >= param_max_pending_list_length)
    3227                 :            :                 {
    3228                 :     220887 :                   add_dependence_list_and_free (deps, insn, &reg_last->sets, 0,
    3229                 :            :                                                 REG_DEP_OUTPUT, false);
    3230                 :     220887 :                   add_dependence_list_and_free (deps, insn,
    3231                 :            :                                                 &reg_last->implicit_sets, 0,
    3232                 :            :                                                 REG_DEP_ANTI, false);
    3233                 :     220887 :                   add_dependence_list_and_free (deps, insn, &reg_last->uses, 0,
    3234                 :            :                                                 REG_DEP_ANTI, false);
    3235                 :     220887 :                   add_dependence_list_and_free (deps, insn,
    3236                 :            :                                                 &reg_last->control_uses, 0,
    3237                 :            :                                                 REG_DEP_ANTI, false);
    3238                 :     220887 :                   add_dependence_list_and_free (deps, insn,
    3239                 :            :                                                 &reg_last->clobbers, 0,
    3240                 :            :                                                 REG_DEP_OUTPUT, false);
    3241                 :            : 
    3242                 :     220887 :                   if (!deps->readonly)
    3243                 :            :                     {
    3244                 :     220883 :                       reg_last->sets = alloc_INSN_LIST (insn, reg_last->sets);
    3245                 :     220883 :                       reg_last->clobbers_length = 0;
    3246                 :     220883 :                       reg_last->uses_length = 0;
    3247                 :            :                     }
    3248                 :            :                 }
    3249                 :            :               else
    3250                 :            :                 {
    3251                 :  209124000 :                   add_dependence_list (insn, reg_last->sets, 0, REG_DEP_OUTPUT,
    3252                 :            :                                        false);
    3253                 :  209124000 :                   add_dependence_list (insn, reg_last->implicit_sets, 0,
    3254                 :            :                                        REG_DEP_ANTI, false);
    3255                 :  209124000 :                   add_dependence_list (insn, reg_last->uses, 0, REG_DEP_ANTI,
    3256                 :            :                                        false);
    3257                 :  209124000 :                   add_dependence_list (insn, reg_last->control_uses, 0,
    3258                 :            :                                        REG_DEP_CONTROL, false);
    3259                 :            :                 }
    3260                 :            : 
    3261                 :  209345000 :               if (!deps->readonly)
    3262                 :            :                 {
    3263                 :  209311000 :                   reg_last->clobbers_length++;
    3264                 :  209311000 :                   reg_last->clobbers
    3265                 :  209311000 :                     = alloc_INSN_LIST (insn, reg_last->clobbers);
    3266                 :            :                 }
    3267                 :            :             }
    3268                 :   60501700 :           EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i, rsi)
    3269                 :            :             {
    3270                 :   24253600 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3271                 :            : 
    3272                 :   24253600 :               add_dependence_list_and_free (deps, insn, &reg_last->sets, 0,
    3273                 :            :                                             REG_DEP_OUTPUT, false);
    3274                 :   24253600 :               add_dependence_list_and_free (deps, insn,
    3275                 :            :                                             &reg_last->implicit_sets,
    3276                 :            :                                             0, REG_DEP_ANTI, false);
    3277                 :   24253600 :               add_dependence_list_and_free (deps, insn, &reg_last->clobbers, 0,
    3278                 :            :                                             REG_DEP_OUTPUT, false);
    3279                 :   24253600 :               add_dependence_list_and_free (deps, insn, &reg_last->uses, 0,
    3280                 :            :                                             REG_DEP_ANTI, false);
    3281                 :   24253600 :               add_dependence_list (insn, reg_last->control_uses, 0,
    3282                 :            :                                    REG_DEP_CONTROL, false);
    3283                 :            : 
    3284                 :   24253600 :               if (!deps->readonly)
    3285                 :            :                 {
    3286                 :   24245300 :                   reg_last->sets = alloc_INSN_LIST (insn, reg_last->sets);
    3287                 :   24245300 :                   reg_last->uses_length = 0;
    3288                 :   24245300 :                   reg_last->clobbers_length = 0;
    3289                 :            :                 }
    3290                 :            :             }
    3291                 :            :         }
    3292                 :   39282400 :       if (!deps->readonly)
    3293                 :            :         {
    3294                 :   39251700 :           EXECUTE_IF_SET_IN_REG_SET (reg_pending_control_uses, 0, i, rsi)
    3295                 :            :             {
    3296                 :        286 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3297                 :        286 :               reg_last->control_uses
    3298                 :        286 :                 = alloc_INSN_LIST (insn, reg_last->control_uses);
    3299                 :            :             }
    3300                 :            :         }
    3301                 :            :     }
    3302                 :            : 
    3303                 : 5161940000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3304                 : 5094900000 :     if (TEST_HARD_REG_BIT (implicit_reg_pending_clobbers, i))
    3305                 :            :       {
    3306                 :       2077 :         struct deps_reg *reg_last = &deps->reg_last[i];
    3307                 :       2077 :         add_dependence_list (insn, reg_last->sets, 0, REG_DEP_ANTI, false);
    3308                 :       2077 :         add_dependence_list (insn, reg_last->clobbers, 0, REG_DEP_ANTI, false);
    3309                 :       2077 :         add_dependence_list (insn, reg_last->uses, 0, REG_DEP_ANTI, false);
    3310                 :       2077 :         add_dependence_list (insn, reg_last->control_uses, 0, REG_DEP_ANTI,
    3311                 :            :                              false);
    3312                 :            : 
    3313                 :       2077 :         if (!deps->readonly)
    3314                 :        902 :           reg_last->implicit_sets
    3315                 :        902 :             = alloc_INSN_LIST (insn, reg_last->implicit_sets);
    3316                 :            :       }
    3317                 :            : 
    3318                 :   67038100 :   if (!deps->readonly)
    3319                 :            :     {
    3320                 :   67006100 :       IOR_REG_SET (&deps->reg_last_in_use, reg_pending_uses);
    3321                 :   67006100 :       IOR_REG_SET (&deps->reg_last_in_use, reg_pending_clobbers);
    3322                 :   67006100 :       IOR_REG_SET (&deps->reg_last_in_use, reg_pending_sets);
    3323                 :  134012000 :       IOR_REG_SET_HRS (&deps->reg_last_in_use,
    3324                 :            :                        implicit_reg_pending_uses
    3325                 :            :                        | implicit_reg_pending_clobbers);
    3326                 :            : 
    3327                 :            :       /* Set up the pending barrier found.  */
    3328                 :   67006100 :       deps->last_reg_pending_barrier = reg_pending_barrier;
    3329                 :            :     }
    3330                 :            : 
    3331                 :   67038100 :   CLEAR_REG_SET (reg_pending_uses);
    3332                 :   67038100 :   CLEAR_REG_SET (reg_pending_clobbers);
    3333                 :   67038100 :   CLEAR_REG_SET (reg_pending_sets);
    3334                 :   67038100 :   CLEAR_REG_SET (reg_pending_control_uses);
    3335                 :   67038100 :   CLEAR_HARD_REG_SET (implicit_reg_pending_clobbers);
    3336                 :  201114000 :   CLEAR_HARD_REG_SET (implicit_reg_pending_uses);
    3337                 :            : 
    3338                 :            :   /* Add dependencies if a scheduling barrier was found.  */
    3339                 :   67038100 :   if (reg_pending_barrier)
    3340                 :            :     {
    3341                 :            :       /* In the case of barrier the most added dependencies are not
    3342                 :            :          real, so we use anti-dependence here.  */
    3343                 :    2824020 :       if (sched_has_condition_p (insn))
    3344                 :            :         {
    3345                 :         15 :           EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
    3346                 :            :             {
    3347                 :         10 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3348                 :         10 :               add_dependence_list (insn, reg_last->uses, 0, REG_DEP_ANTI,
    3349                 :            :                                    true);
    3350                 :         10 :               add_dependence_list (insn, reg_last->sets, 0,
    3351                 :         10 :                                    reg_pending_barrier == TRUE_BARRIER
    3352                 :            :                                    ? REG_DEP_TRUE : REG_DEP_ANTI, true);
    3353                 :         10 :               add_dependence_list (insn, reg_last->implicit_sets, 0,
    3354                 :            :                                    REG_DEP_ANTI, true);
    3355                 :         10 :               add_dependence_list (insn, reg_last->clobbers, 0,
    3356                 :         10 :                                    reg_pending_barrier == TRUE_BARRIER
    3357                 :            :                                    ? REG_DEP_TRUE : REG_DEP_ANTI, true);
    3358                 :            :             }
    3359                 :            :         }
    3360                 :            :       else
    3361                 :            :         {
    3362                 :  117858000 :           EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
    3363                 :            :             {
    3364                 :  115034000 :               struct deps_reg *reg_last = &deps->reg_last[i];
    3365                 :  115034000 :               add_dependence_list_and_free (deps, insn, &reg_last->uses, 0,
    3366                 :            :                                             REG_DEP_ANTI, true);
    3367                 :  115034000 :               add_dependence_list_and_free (deps, insn,
    3368                 :            :                                             &reg_last->control_uses, 0,
    3369                 :            :                                             REG_DEP_CONTROL, true);
    3370                 :  115034000 :               add_dependence_list_and_free (deps, insn, &reg_last->sets, 0,
    3371                 :  115034000 :                                             reg_pending_barrier == TRUE_BARRIER
    3372                 :            :                                             ? REG_DEP_TRUE : REG_DEP_ANTI,
    3373                 :            :                                             true);
    3374                 :  115034000 :               add_dependence_list_and_free (deps, insn,
    3375                 :            :                                             &reg_last->implicit_sets, 0,
    3376                 :            :                                             REG_DEP_ANTI, true);
    3377                 :  115034000 :               add_dependence_list_and_free (deps, insn, &reg_last->clobbers, 0,
    3378                 :  115034000 :                                             reg_pending_barrier == TRUE_BARRIER
    3379                 :            :                                             ? REG_DEP_TRUE : REG_DEP_ANTI,
    3380                 :            :                                             true);
    3381                 :            : 
    3382                 :  115034000 :               if (!deps->readonly)
    3383                 :            :                 {
    3384                 :  115029000 :                   reg_last->uses_length = 0;
    3385                 :  115029000 :                   reg_last->clobbers_length = 0;
    3386                 :            :                 }
    3387                 :            :             }
    3388                 :            :         }
    3389                 :            : 
    3390                 :    2824020 :       if (!deps->readonly)
    3391                 :  217440000 :         for (i = 0; i < (unsigned)deps->max_reg; i++)
    3392                 :            :           {
    3393                 :  214616000 :             struct deps_reg *reg_last = &deps->reg_last[i];
    3394                 :  214616000 :             reg_last->sets = alloc_INSN_LIST (insn, reg_last->sets);
    3395                 :  214616000 :             SET_REGNO_REG_SET (&deps->reg_last_in_use, i);
    3396                 :            :           }
    3397                 :            : 
    3398                 :            :       /* Don't flush pending lists on speculative checks for
    3399                 :            :          selective scheduling.  */
    3400                 :    2824020 :       if (!sel_sched_p () || !sel_insn_is_speculation_check (insn))
    3401                 :    2824020 :         flush_pending_lists (deps, insn, true, true);
    3402                 :            : 
    3403                 :    2824020 :       reg_pending_barrier = NOT_A_BARRIER;
    3404                 :            :     }
    3405                 :            : 
    3406                 :            :   /* If a post-call group is still open, see if it should remain so.
    3407                 :            :      This insn must be a simple move of a hard reg to a pseudo or
    3408                 :            :      vice-versa.
    3409                 :            : 
    3410                 :            :      We must avoid moving these insns for correctness on targets
    3411                 :            :      with small register classes, and for special registers like
    3412                 :            :      PIC_OFFSET_TABLE_REGNUM.  For simplicity, extend this to all
    3413                 :            :      hard regs for all targets.  */
    3414                 :            : 
    3415                 :   67038100 :   if (deps->in_post_call_group_p)
    3416                 :            :     {
    3417                 :       1749 :       rtx tmp, set = single_set (insn);
    3418                 :       1749 :       int src_regno, dest_regno;
    3419                 :            : 
    3420                 :       1749 :       if (set == NULL)
    3421                 :            :         {
    3422                 :        411 :           if (DEBUG_INSN_P (insn))
    3423                 :            :             /* We don't want to mark debug insns as part of the same
    3424                 :            :                sched group.  We know they really aren't, but if we use
    3425                 :            :                debug insns to tell that a call group is over, we'll
    3426                 :            :                get different code if debug insns are not there and
    3427                 :            :                instructions that follow seem like they should be part
    3428                 :            :                of the call group.
    3429                 :            : 
    3430                 :            :                Also, if we did, chain_to_prev_insn would move the
    3431                 :            :                deps of the debug insn to the call insn, modifying
    3432                 :            :                non-debug post-dependency counts of the debug insn
    3433                 :            :                dependencies and otherwise messing with the scheduling
    3434                 :            :                order.
    3435                 :            : 
    3436                 :            :                Instead, let such debug insns be scheduled freely, but
    3437                 :            :                keep the call group open in case there are insns that
    3438                 :            :                should be part of it afterwards.  Since we grant debug
    3439                 :            :                insns higher priority than even sched group insns, it
    3440                 :            :                will all turn out all right.  */
    3441                 :        318 :             goto debug_dont_end_call_group;
    3442                 :            :           else
    3443                 :         93 :             goto end_call_group;
    3444                 :            :         }
    3445                 :            : 
    3446                 :       1338 :       tmp = SET_DEST (set);
    3447                 :       1338 :       if (GET_CODE (tmp) == SUBREG)
    3448                 :          0 :         tmp = SUBREG_REG (tmp);
    3449                 :       1338 :       if (REG_P (tmp))
    3450                 :       1273 :         dest_regno = REGNO (tmp);
    3451                 :            :       else
    3452                 :         65 :         goto end_call_group;
    3453                 :            : 
    3454                 :       1273 :       tmp = SET_SRC (set);
    3455                 :       1273 :       if (GET_CODE (tmp) == SUBREG)
    3456                 :         37 :         tmp = SUBREG_REG (tmp);
    3457                 :       1273 :       if ((GET_CODE (tmp) == PLUS
    3458                 :       1273 :            || GET_CODE (tmp) == MINUS)
    3459                 :         86 :           && REG_P (XEXP (tmp, 0))
    3460                 :         76 :           && REGNO (XEXP (tmp, 0)) == STACK_POINTER_REGNUM
    3461                 :       1285 :           && dest_regno == STACK_POINTER_REGNUM)
    3462                 :            :         src_regno = STACK_POINTER_REGNUM;
    3463                 :       1261 :       else if (REG_P (tmp))
    3464                 :        619 :         src_regno = REGNO (tmp);
    3465                 :            :       else
    3466                 :        642 :         goto end_call_group;
    3467                 :            : 
    3468                 :        631 :       if (src_regno < FIRST_PSEUDO_REGISTER
    3469                 :        631 :           || dest_regno < FIRST_PSEUDO_REGISTER)
    3470                 :            :         {
    3471                 :        465 :           if (!deps->readonly
    3472                 :        394 :               && deps->in_post_call_group_p == post_call_initial)
    3473                 :          0 :             deps->in_post_call_group_p = post_call;
    3474                 :            : 
    3475                 :        465 :           if (!sel_sched_p () || sched_emulate_haifa_p)
    3476                 :            :             {
    3477                 :        368 :               SCHED_GROUP_P (insn) = 1;
    3478                 :        368 :               CANT_MOVE (insn) = 1;
    3479                 :            :             }
    3480                 :            :         }
    3481                 :            :       else
    3482                 :            :         {
    3483                 :        166 :         end_call_group:
    3484                 :        966 :           if (!deps->readonly)
    3485                 :        805 :             deps->in_post_call_group_p = not_post_call;
    3486                 :            :         }
    3487                 :            :     }
    3488                 :            : 
    3489                 :   67036400 :  debug_dont_end_call_group:
    3490                 :   67038100 :   if ((current_sched_info->flags & DO_SPECULATION)
    3491                 :   67038100 :       && !sched_insn_is_legitimate_for_speculation_p (insn, 0))
    3492                 :            :     /* INSN has an internal dependency (e.g. r14 = [r14]) and thus cannot
    3493                 :            :        be speculated.  */
    3494                 :            :     {
    3495                 :          0 :       if (sel_sched_p ())
    3496                 :          0 :         sel_mark_hard_insn (insn);
    3497                 :            :       else
    3498                 :            :         {
    3499                 :          0 :           sd_iterator_def sd_it;
    3500                 :          0 :           dep_t dep;
    3501                 :            : 
    3502                 :          0 :           for (sd_it = sd_iterator_start (insn, SD_LIST_SPEC_BACK);
    3503                 :          0 :                sd_iterator_cond (&sd_it, &dep);)
    3504                 :          0 :             change_spec_dep_to_hard (sd_it);
    3505                 :            :         }
    3506                 :            :     }
    3507                 :            : 
    3508                 :            :   /* We do not yet have code to adjust REG_ARGS_SIZE, therefore we must
    3509                 :            :      honor their original ordering.  */
    3510                 :   67038100 :   if (find_reg_note (insn, REG_ARGS_SIZE, NULL))
    3511                 :            :     {
    3512                 :    3549660 :       if (deps->last_args_size)
    3513                 :    2570720 :         add_dependence (insn, deps->last_args_size, REG_DEP_OUTPUT);
    3514                 :    3549660 :       if (!deps->readonly)
    3515                 :    3549500 :         deps->last_args_size = insn;
    3516                 :            :     }
    3517                 :            : 
    3518                 :            :   /* We must not mix prologue and epilogue insns.  See PR78029.  */
    3519                 :   67038100 :   if (prologue_contains (insn))
    3520                 :            :     {
    3521                 :    2166390 :       add_dependence_list (insn, deps->last_epilogue, true, REG_DEP_ANTI, true);
    3522                 :    2166390 :       if (!deps->readonly)
    3523                 :            :         {
    3524                 :    2166100 :           if (deps->last_logue_was_epilogue)
    3525                 :          0 :             free_INSN_LIST_list (&deps->last_prologue);
    3526                 :    2166100 :           deps->last_prologue = alloc_INSN_LIST (insn, deps->last_prologue);
    3527                 :    2166100 :           deps->last_logue_was_epilogue = false;
    3528                 :            :         }
    3529                 :            :     }
    3530                 :            : 
    3531                 :   67038100 :   if (epilogue_contains (insn))
    3532                 :            :     {
    3533                 :    2115920 :       add_dependence_list (insn, deps->last_prologue, true, REG_DEP_ANTI, true);
    3534                 :    2115920 :       if (!deps->readonly)
    3535                 :            :         {
    3536                 :    2115500 :           if (!deps->last_logue_was_epilogue)
    3537                 :     703300 :             free_INSN_LIST_list (&deps->last_epilogue);
    3538                 :    2115500 :           deps->last_epilogue = alloc_INSN_LIST (insn, deps->last_epilogue);
    3539                 :    2115500 :           deps->last_logue_was_epilogue = true;
    3540                 :            :         }
    3541                 :            :     }
    3542                 :   67038100 : }
    3543                 :            : 
    3544                 :            : /* Return TRUE if INSN might not always return normally (e.g. call exit,
    3545                 :            :    longjmp, loop forever, ...).  */
    3546                 :            : /* FIXME: Why can't this function just use flags_from_decl_or_type and
    3547                 :            :    test for ECF_NORETURN?  */
    3548                 :            : static bool
    3549                 :    3050120 : call_may_noreturn_p (rtx_insn *insn)
    3550                 :            : {
    3551                 :    3050120 :   rtx call;
    3552                 :            : 
    3553                 :            :   /* const or pure calls that aren't looping will always return.  */
    3554                 :    5997480 :   if (RTL_CONST_OR_PURE_CALL_P (insn)
    3555                 :    3129560 :       && !RTL_LOOPING_CONST_OR_PURE_CALL_P (insn))
    3556                 :            :     return false;
    3557                 :            : 
    3558                 :    2892590 :   call = get_call_rtx_from (insn);
    3559                 :    2892590 :   if (call && GET_CODE (XEXP (XEXP (call, 0), 0)) == SYMBOL_REF)
    3560                 :            :     {
    3561                 :    2776120 :       rtx symbol = XEXP (XEXP (call, 0), 0);
    3562                 :    2776120 :       if (SYMBOL_REF_DECL (symbol)
    3563                 :    2776120 :           && TREE_CODE (SYMBOL_REF_DECL (symbol)) == FUNCTION_DECL)
    3564                 :            :         {
    3565                 :    2611750 :           if (DECL_BUILT_IN_CLASS (SYMBOL_REF_DECL (symbol))
    3566                 :    2611750 :               == BUILT_IN_NORMAL)
    3567                 :     358782 :             switch (DECL_FUNCTION_CODE (SYMBOL_REF_DECL (symbol)))
    3568                 :            :               {
    3569                 :      62188 :               case BUILT_IN_BCMP:
    3570                 :      62188 :               case BUILT_IN_BCOPY:
    3571                 :      62188 :               case BUILT_IN_BZERO:
    3572                 :      62188 :               case BUILT_IN_INDEX:
    3573                 :      62188 :               case BUILT_IN_MEMCHR:
    3574                 :      62188 :               case BUILT_IN_MEMCMP:
    3575                 :      62188 :               case BUILT_IN_MEMCPY:
    3576                 :      62188 :               case BUILT_IN_MEMMOVE:
    3577                 :      62188 :               case BUILT_IN_MEMPCPY:
    3578                 :      62188 :               case BUILT_IN_MEMSET:
    3579                 :      62188 :               case BUILT_IN_RINDEX:
    3580                 :      62188 :               case BUILT_IN_STPCPY:
    3581                 :      62188 :               case BUILT_IN_STPNCPY:
    3582                 :      62188 :               case BUILT_IN_STRCAT:
    3583                 :      62188 :               case BUILT_IN_STRCHR:
    3584                 :      62188 :               case BUILT_IN_STRCMP:
    3585                 :      62188 :               case BUILT_IN_STRCPY:
    3586                 :      62188 :               case BUILT_IN_STRCSPN:
    3587                 :      62188 :               case BUILT_IN_STRLEN:
    3588                 :      62188 :               case BUILT_IN_STRNCAT:
    3589                 :      62188 :               case BUILT_IN_STRNCMP:
    3590                 :      62188 :               case BUILT_IN_STRNCPY:
    3591                 :      62188 :               case BUILT_IN_STRPBRK:
    3592                 :      62188 :               case BUILT_IN_STRRCHR:
    3593                 :      62188 :               case BUILT_IN_STRSPN:
    3594                 :      62188 :               case BUILT_IN_STRSTR:
    3595                 :            :                 /* Assume certain string/memory builtins always return.  */
    3596                 :      62188 :                 return false;
    3597                 :            :               default:
    3598                 :            :                 break;
    3599                 :            :               }
    3600                 :            :         }
    3601                 :            :     }
    3602                 :            : 
    3603                 :            :   /* For all other calls assume that they might not always return.  */
    3604                 :            :   return true;
    3605                 :            : }
    3606                 :            : 
    3607                 :            : /* Return true if INSN should be made dependent on the previous instruction
    3608                 :            :    group, and if all INSN's dependencies should be moved to the first
    3609                 :            :    instruction of that group.  */
    3610                 :            : 
    3611                 :            : static bool
    3612                 :   36231800 : chain_to_prev_insn_p (rtx_insn *insn)
    3613                 :            : {
    3614                 :            :   /* INSN forms a group with the previous instruction.  */
    3615                 :   36231800 :   if (SCHED_GROUP_P (insn))
    3616                 :            :     return true;
    3617                 :            : 
    3618                 :            :   /* If the previous instruction clobbers a register R and this one sets
    3619                 :            :      part of R, the clobber was added specifically to help us track the
    3620                 :            :      liveness of R.  There's no point scheduling the clobber and leaving
    3621                 :            :      INSN behind, especially if we move the clobber to another block.  */
    3622                 :   33856400 :   rtx_insn *prev = prev_nonnote_nondebug_insn (insn);
    3623                 :   33856400 :   if (prev
    3624                 :   33217700 :       && INSN_P (prev)
    3625                 :   30257000 :       && BLOCK_FOR_INSN (prev) == BLOCK_FOR_INSN (insn)
    3626                 :   61441900 :       && GET_CODE (PATTERN (prev)) == CLOBBER)
    3627                 :            :     {
    3628                 :      62600 :       rtx x = XEXP (PATTERN (prev), 0);
    3629                 :      62600 :       if (set_of (x, insn))
    3630                 :         21 :         return true;
    3631                 :            :     }
    3632                 :            : 
    3633                 :            :   return false;
    3634                 :            : }
    3635                 :            : 
    3636                 :            : /* Analyze INSN with DEPS as a context.  */
    3637                 :            : void
    3638                 :   70924600 : deps_analyze_insn (class deps_desc *deps, rtx_insn *insn)
    3639                 :            : {
    3640                 :   70924600 :   if (sched_deps_info->start_insn)
    3641                 :   70905500 :     sched_deps_info->start_insn (insn);
    3642                 :            : 
    3643                 :            :   /* Record the condition for this insn.  */
    3644                 :   70924600 :   if (NONDEBUG_INSN_P (insn))
    3645                 :            :     {
    3646                 :   39282400 :       rtx t;
    3647                 :   39282400 :       sched_get_condition_with_rev (insn, NULL);
    3648                 :   39282400 :       t = INSN_CACHED_COND (insn);
    3649                 :   39282400 :       INSN_COND_DEPS (insn) = NULL;
    3650                 :   39282400 :       if (reload_completed
    3651                 :   39282400 :           && (current_sched_info->flags & DO_PREDICATION)
    3652                 :          0 :           && COMPARISON_P (t)
    3653                 :          0 :           && REG_P (XEXP (t, 0))
    3654                 :          0 :           && CONSTANT_P (XEXP (t, 1)))
    3655                 :            :         {
    3656                 :          0 :           unsigned int regno;
    3657                 :          0 :           int nregs;
    3658                 :          0 :           rtx_insn_list *cond_deps = NULL;
    3659                 :          0 :           t = XEXP (t, 0);
    3660                 :          0 :           regno = REGNO (t);
    3661                 :          0 :           nregs = REG_NREGS (t);
    3662                 :          0 :           while (nregs-- > 0)
    3663                 :            :             {
    3664                 :          0 :               struct deps_reg *reg_last = &deps->reg_last[regno + nregs];
    3665                 :          0 :               cond_deps = concat_INSN_LIST (reg_last->sets, cond_deps);
    3666                 :          0 :               cond_deps = concat_INSN_LIST (reg_last->clobbers, cond_deps);
    3667                 :          0 :               cond_deps = concat_INSN_LIST (reg_last->implicit_sets, cond_deps);
    3668                 :            :             }
    3669                 :          0 :           INSN_COND_DEPS (insn) = cond_deps;
    3670                 :            :         }
    3671                 :            :     }
    3672                 :            : 
    3673                 :   70924600 :   if (JUMP_P (insn))
    3674                 :            :     {
    3675                 :            :       /* Make each JUMP_INSN (but not a speculative check)
    3676                 :            :          a scheduling barrier for memory references.  */
    3677                 :    4820460 :       if (!deps->readonly
    3678                 :    4822020 :           && !(sel_sched_p ()
    3679                 :       1558 :                && sel_insn_is_speculation_check (insn)))
    3680                 :            :         {
    3681                 :            :           /* Keep the list a reasonable size.  */
    3682                 :    4819130 :           if (deps->pending_flush_length++ >= param_max_pending_list_length)
    3683                 :          2 :             flush_pending_lists (deps, insn, true, true);
    3684                 :            :           else
    3685                 :    4819120 :             deps->pending_jump_insns
    3686                 :    4819120 :               = alloc_INSN_LIST (insn, deps->pending_jump_insns);
    3687                 :            :         }
    3688                 :            : 
    3689                 :            :       /* For each insn which shouldn't cross a jump, add a dependence.  */
    3690                 :    4820460 :       add_dependence_list_and_free (deps, insn,
    3691                 :            :                                     &deps->sched_before_next_jump, 1,
    3692                 :            :                                     REG_DEP_ANTI, true);
    3693                 :            : 
    3694                 :    4820460 :       sched_analyze_insn (deps, PATTERN (insn), insn);
    3695                 :            :     }
    3696                 :   66104200 :   else if (NONJUMP_INSN_P (insn) || DEBUG_INSN_P (insn))
    3697                 :            :     {
    3698                 :   59167100 :       sched_analyze_insn (deps, PATTERN (insn), insn);
    3699                 :            :     }
    3700                 :    6937070 :   else if (CALL_P (insn))
    3701                 :            :     {
    3702                 :    3050610 :       int i;
    3703                 :            : 
    3704                 :    3050610 :       CANT_MOVE (insn) = 1;
    3705                 :            : 
    3706                 :    3050610 :       if (find_reg_note (insn, REG_SETJMP, NULL))
    3707                 :            :         {
    3708                 :            :           /* This is setjmp.  Assume that all registers, not just
    3709                 :            :              hard registers, may be clobbered by this call.  */
    3710                 :        434 :           reg_pending_barrier = MOVE_BARRIER;
    3711                 :            :         }
    3712                 :            :       else
    3713                 :            :         {
    3714                 :    3050170 :           function_abi callee_abi = insn_callee_abi (insn);
    3715                 :  234863000 :           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    3716                 :            :             /* A call may read and modify global register variables.  */
    3717                 :  231813000 :             if (global_regs[i])
    3718                 :            :               {
    3719                 :         20 :                 SET_REGNO_REG_SET (reg_pending_sets, i);
    3720                 :         20 :                 SET_HARD_REG_BIT (implicit_reg_pending_uses, i);
    3721                 :            :               }
    3722                 :            :           /* Other call-clobbered hard regs may be clobbered.
    3723                 :            :              Since we only have a choice between 'might be clobbered'
    3724                 :            :              and 'definitely not clobbered', we must include all
    3725                 :            :              partly call-clobbered registers here.  */
    3726                 :  231813000 :             else if (callee_abi.clobbers_at_least_part_of_reg_p (i))
    3727                 :  200501000 :               SET_REGNO_REG_SET (reg_pending_clobbers, i);
    3728                 :            :           /* We don't know what set of fixed registers might be used
    3729                 :            :              by the function, but it is certain that the stack pointer
    3730                 :            :              is among them, but be conservative.  */
    3731                 :   31311900 :             else if (fixed_regs[i])
    3732                 :    9161110 :               SET_HARD_REG_BIT (implicit_reg_pending_uses, i);
    3733                 :            :           /* The frame pointer is normally not used by the function
    3734                 :            :              itself, but by the debugger.  */
    3735                 :            :           /* ??? MIPS o32 is an exception.  It uses the frame pointer
    3736                 :            :              in the macro expansion of jal but does not represent this
    3737                 :            :              fact in the call_insn rtl.  */
    3738                 :   22150700 :             else if (i == FRAME_POINTER_REGNUM
    3739                 :   22150700 :                      || (i == HARD_FRAME_POINTER_REGNUM
    3740                 :    3050170 :                          && (! reload_completed || frame_pointer_needed)))
    3741                 :  231813000 :               SET_HARD_REG_BIT (implicit_reg_pending_uses, i);
    3742                 :            :         }
    3743                 :            : 
    3744                 :            :       /* For each insn which shouldn't cross a call, add a dependence
    3745                 :            :          between that insn and this call insn.  */
    3746                 :    3050610 :       add_dependence_list_and_free (deps, insn,
    3747                 :            :                                     &deps->sched_before_next_call, 1,
    3748                 :            :                                     REG_DEP_ANTI, true);
    3749                 :            : 
    3750                 :    3050610 :       sched_analyze_insn (deps, PATTERN (insn), insn);
    3751                 :            : 
    3752                 :            :       /* If CALL would be in a sched group, then this will violate
    3753                 :            :          convention that sched group insns have dependencies only on the
    3754                 :            :          previous instruction.
    3755                 :            : 
    3756                 :            :          Of course one can say: "Hey!  What about head of the sched group?"
    3757                 :            :          And I will answer: "Basic principles (one dep per insn) are always
    3758                 :            :          the same."  */
    3759                 :    3050610 :       gcc_assert (!SCHED_GROUP_P (insn));
    3760                 :            : 
    3761                 :            :       /* In the absence of interprocedural alias analysis, we must flush
    3762                 :            :          all pending reads and writes, and start new dependencies starting
    3763                 :            :          from here.  But only flush writes for constant calls (which may
    3764                 :            :          be passed a pointer to something we haven't written yet).  */
    3765                 :    3232880 :       flush_pending_lists (deps, insn, true, ! RTL_CONST_OR_PURE_CALL_P (insn));
    3766                 :            : 
    3767                 :    3050610 :       if (!deps->readonly)
    3768                 :            :         {
    3769                 :            :           /* Remember the last function call for limiting lifetimes.  */
    3770                 :    3050120 :           free_INSN_LIST_list (&deps->last_function_call);
    3771                 :    3050120 :           deps->last_function_call = alloc_INSN_LIST (insn, NULL_RTX);
    3772                 :            : 
    3773                 :    3050120 :           if (call_may_noreturn_p (insn))
    3774                 :            :             {
    3775                 :            :               /* Remember the last function call that might not always return
    3776                 :            :                  normally for limiting moves of trapping insns.  */
    3777                 :    2830410 :               free_INSN_LIST_list (&deps->last_function_call_may_noreturn);
    3778                 :    2830410 :               deps->last_function_call_may_noreturn
    3779                 :    2830410 :                 = alloc_INSN_LIST (insn, NULL_RTX);
    3780                 :            :             }
    3781                 :            : 
    3782                 :            :           /* Before reload, begin a post-call group, so as to keep the
    3783                 :            :              lifetimes of hard registers correct.  */
    3784                 :    3050120 :           if (! reload_completed)
    3785                 :        940 :             deps->in_post_call_group_p = post_call;
    3786                 :            :         }
    3787                 :            :     }
    3788                 :            : 
    3789                 :   70924600 :   if (sched_deps_info->use_cselib)
    3790                 :       1590 :     cselib_process_insn (insn);
    3791                 :            : 
    3792                 :   70924600 :   if (sched_deps_info->finish_insn)
    3793                 :   70905500 :     sched_deps_info->finish_insn ();
    3794                 :            : 
    3795                 :            :   /* Fixup the dependencies in the sched group.  */
    3796                 :   70924600 :   if ((NONJUMP_INSN_P (insn) || JUMP_P (insn))
    3797                 :   36231800 :       && chain_to_prev_insn_p (insn)
    3798                 :   73300000 :       && !sel_sched_p ())
    3799                 :    2374110 :     chain_to_prev_insn (insn);
    3800                 :   70924600 : }
    3801                 :            : 
    3802                 :            : /* Initialize DEPS for the new block beginning with HEAD.  */
    3803                 :            : void
    3804                 :    6525750 : deps_start_bb (class deps_desc *deps, rtx_insn *head)
    3805                 :            : {
    3806                 :    6525750 :   gcc_assert (!deps->readonly);
    3807                 :            : 
    3808                 :            :   /* Before reload, if the previous block ended in a call, show that
    3809                 :            :      we are inside a post-call group, so as to keep the lifetimes of
    3810                 :            :      hard registers correct.  */
    3811                 :    6525750 :   if (! reload_completed && !LABEL_P (head))
    3812                 :            :     {
    3813                 :       1511 :       rtx_insn *insn = prev_nonnote_nondebug_insn (head);
    3814                 :            : 
    3815                 :       1511 :       if (insn && CALL_P (insn))
    3816                 :          5 :         deps->in_post_call_group_p = post_call_initial;
    3817                 :            :     }
    3818                 :    6525750 : }
    3819                 :            : 
    3820                 :            : /* Analyze every insn between HEAD and TAIL inclusive, creating backward
    3821                 :            :    dependencies for each insn.  */
    3822                 :            : void
    3823                 :    6525750 : sched_analyze (class deps_desc *deps, rtx_insn *head, rtx_insn *tail)
    3824                 :            : {
    3825                 :    6525750 :   rtx_insn *insn;
    3826                 :            : 
    3827                 :    6525750 :   if (sched_deps_info->use_cselib)
    3828                 :        287 :     cselib_init (CSELIB_RECORD_MEMORY);
    3829                 :            : 
    3830                 :    6525750 :   deps_start_bb (deps, head);
    3831                 :            : 
    3832                 :   70883600 :   for (insn = head;; insn = NEXT_INSN (insn))
    3833                 :            :     {
    3834                 :            : 
    3835                 :   70883600 :       if (INSN_P (insn))
    3836                 :            :         {
    3837                 :            :           /* And initialize deps_lists.  */
    3838                 :   66997100 :           sd_init_insn (insn);
    3839                 :            :           /* Clean up SCHED_GROUP_P which may be set by last
    3840                 :            :              scheduler pass.  */
    3841                 :   66997100 :           if (SCHED_GROUP_P (insn))
    3842                 :         20 :             SCHED_GROUP_P (insn) = 0;
    3843                 :            :         }
    3844                 :            : 
    3845                 :   70883600 :       deps_analyze_insn (deps, insn);
    3846                 :            : 
    3847                 :   70883600 :       if (insn == tail)
    3848                 :            :         {
    3849                 :    6525750 :           if (sched_deps_info->use_cselib)
    3850                 :        287 :             cselib_finish ();
    3851                 :    6525750 :           return;
    3852                 :            :         }
    3853                 :   64357800 :     }
    3854                 :            :   gcc_unreachable ();
    3855                 :            : }
    3856                 :            : 
    3857                 :            : /* Helper for sched_free_deps ().
    3858                 :            :    Delete INSN's (RESOLVED_P) backward dependencies.  */
    3859                 :            : static void
    3860                 :   66997100 : delete_dep_nodes_in_back_deps (rtx_insn *insn, bool resolved_p)
    3861                 :            : {
    3862                 :   66997100 :   sd_iterator_def sd_it;
    3863                 :   66997100 :   dep_t dep;
    3864                 :   66997100 :   sd_list_types_def types;
    3865                 :            : 
    3866                 :   66997100 :   if (resolved_p)
    3867                 :            :     types = SD_LIST_RES_BACK;
    3868                 :            :   else
    3869                 :       4198 :     types = SD_LIST_BACK;
    3870                 :            : 
    3871                 :  201107000 :   for (sd_it = sd_iterator_start (insn, types);
    3872                 :  201107000 :        sd_iterator_cond (&sd_it, &dep);)
    3873                 :            :     {
    3874                 :  134110000 :       dep_link_t link = *sd_it.linkp;
    3875                 :  134110000 :       dep_node_t node = DEP_LINK_NODE (link);
    3876                 :  134110000 :       deps_list_t back_list;
    3877                 :  134110000 :       deps_list_t forw_list;
    3878                 :            : 
    3879                 :  134110000 :       get_back_and_forw_lists (dep, resolved_p, &back_list, &forw_list);
    3880                 :  134110000 :       remove_from_deps_list (link, back_list);
    3881                 :  134110000 :       delete_dep_node (node);
    3882                 :            :     }
    3883                 :   66997100 : }
    3884                 :            : 
    3885                 :            : /* Delete (RESOLVED_P) dependencies between HEAD and TAIL together with
    3886                 :            :    deps_lists.  */
    3887                 :            : void
    3888                 :    6520090 : sched_free_deps (rtx_insn *head, rtx_insn *tail, bool resolved_p)
    3889                 :            : {
    3890                 :    6520090 :   rtx_insn *insn;
    3891                 :    6520090 :   rtx_insn *next_tail = NEXT_INSN (tail);
    3892                 :            : 
    3893                 :            :   /* We make two passes since some insns may be scheduled before their
    3894                 :            :      dependencies are resolved.  */
    3895                 :  141600000 :   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
    3896                 :   67539800 :     if (INSN_P (insn) && INSN_LUID (insn) > 0)
    3897                 :            :       {
    3898                 :            :         /* Clear forward deps and leave the dep_nodes to the
    3899                 :            :            corresponding back_deps list.  */
    3900                 :   66997100 :         if (resolved_p)
    3901                 :   66992900 :           clear_deps_list (INSN_RESOLVED_FORW_DEPS (insn));
    3902                 :            :         else
    3903                 :       4198 :           clear_deps_list (INSN_FORW_DEPS (insn));
    3904                 :            :       }
    3905                 :   74059900 :   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
    3906                 :   67539800 :     if (INSN_P (insn) && INSN_LUID (insn) > 0)
    3907                 :            :       {
    3908                 :            :         /* Clear resolved back deps together with its dep_nodes.  */
    3909                 :   66997100 :         delete_dep_nodes_in_back_deps (insn, resolved_p);
    3910                 :            : 
    3911                 :   66997100 :         sd_finish_insn (insn);
    3912                 :            :       }
    3913                 :    6520090 : }
    3914                 :            : 
    3915                 :            : /* Initialize variables for region data dependence analysis.
    3916                 :            :    When LAZY_REG_LAST is true, do not allocate reg_last array
    3917                 :            :    of class deps_desc immediately.  */
    3918                 :            : 
    3919                 :            : void
    3920                 :    6532340 : init_deps (class deps_desc *deps, bool lazy_reg_last)
    3921                 :            : {
    3922                 :    6532340 :   int max_reg = (reload_completed ? FIRST_PSEUDO_REGISTER : max_reg_num ());
    3923                 :            : 
    3924                 :    6532340 :   deps->max_reg = max_reg;
    3925                 :    6532340 :   if (lazy_reg_last)
    3926                 :       4847 :     deps->reg_last = NULL;
    3927                 :            :   else
    3928                 :    6527490 :     deps->reg_last = XCNEWVEC (struct deps_reg, max_reg);
    3929                 :    6532340 :   INIT_REG_SET (&deps->reg_last_in_use);
    3930                 :            : 
    3931                 :    6532340 :   deps->pending_read_insns = 0;
    3932                 :    6532340 :   deps->pending_read_mems = 0;
    3933                 :    6532340 :   deps->pending_write_insns = 0;
    3934                 :    6532340 :   deps->pending_write_mems = 0;
    3935                 :    6532340 :   deps->pending_jump_insns = 0;
    3936                 :    6532340 :   deps->pending_read_list_length = 0;
    3937                 :    6532340 :   deps->pending_write_list_length = 0;
    3938                 :    6532340 :   deps->pending_flush_length = 0;
    3939                 :    6532340 :   deps->last_pending_memory_flush = 0;
    3940                 :    6532340 :   deps->last_function_call = 0;
    3941                 :    6532340 :   deps->last_function_call_may_noreturn = 0;
    3942                 :    6532340 :   deps->sched_before_next_call = 0;
    3943                 :    6532340 :   deps->sched_before_next_jump = 0;
    3944                 :    6532340 :   deps->in_post_call_group_p = not_post_call;
    3945                 :    6532340 :   deps->last_debug_insn = 0;
    3946                 :    6532340 :   deps->last_args_size = 0;
    3947                 :    6532340 :   deps->last_prologue = 0;
    3948                 :    6532340 :   deps->last_epilogue = 0;
    3949                 :    6532340 :   deps->last_logue_was_epilogue = false;
    3950                 :    6532340 :   deps->last_reg_pending_barrier = NOT_A_BARRIER;
    3951                 :    6532340 :   deps->readonly = 0;
    3952                 :    6532340 : }
    3953                 :            : 
    3954                 :            : /* Init only reg_last field of DEPS, which was not allocated before as
    3955                 :            :    we inited DEPS lazily.  */
    3956                 :            : void
    3957                 :       3448 : init_deps_reg_last (class deps_desc *deps)
    3958                 :            : {
    3959                 :       3448 :   gcc_assert (deps && deps->max_reg > 0);
    3960                 :       3448 :   gcc_assert (deps->reg_last == NULL);
    3961                 :            : 
    3962                 :       3448 :   deps->reg_last = XCNEWVEC (struct deps_reg, deps->max_reg);
    3963                 :       3448 : }
    3964                 :            : 
    3965                 :            : 
    3966                 :            : /* Free insn lists found in DEPS.  */
    3967                 :            : 
    3968                 :            : void
    3969                 :    6532340 : free_deps (class deps_desc *deps)
    3970                 :            : {
    3971                 :    6532340 :   unsigned i;
    3972                 :    6532340 :   reg_set_iterator rsi;
    3973                 :            : 
    3974                 :            :   /* We set max_reg to 0 when this context was already freed.  */
    3975                 :    6532340 :   if (deps->max_reg == 0)
    3976                 :            :     {
    3977                 :          0 :       gcc_assert (deps->reg_last == NULL);
    3978                 :          0 :       return;
    3979                 :            :     }
    3980                 :    6532340 :   deps->max_reg = 0;
    3981                 :            : 
    3982                 :    6532340 :   free_INSN_LIST_list (&deps->pending_read_insns);
    3983                 :    6532340 :   free_EXPR_LIST_list (&deps->pending_read_mems);
    3984                 :    6532340 :   free_INSN_LIST_list (&deps->pending_write_insns);
    3985                 :    6532340 :   free_EXPR_LIST_list (&deps->pending_write_mems);
    3986                 :    6532340 :   free_INSN_LIST_list (&deps->last_pending_memory_flush);
    3987                 :            : 
    3988                 :            :   /* Without the EXECUTE_IF_SET, this loop is executed max_reg * nr_regions
    3989                 :            :      times.  For a testcase with 42000 regs and 8000 small basic blocks,
    3990                 :            :      this loop accounted for nearly 60% (84 sec) of the total -O2 runtime.  */
    3991                 :  279034000 :   EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
    3992                 :            :     {
    3993                 :  272501000 :       struct deps_reg *reg_last = &deps->reg_last[i];
    3994                 :  272501000 :       if (reg_last->uses)
    3995                 :   17910600 :         free_INSN_LIST_list (&reg_last->uses);
    3996                 :  272501000 :       if (reg_last->sets)
    3997                 :  192263000 :         free_INSN_LIST_list (&reg_last->sets);
    3998                 :  272501000 :       if (reg_last->implicit_sets)
    3999                 :        440 :         free_INSN_LIST_list (&reg_last->implicit_sets);
    4000                 :  272501000 :       if (reg_last->control_uses)
    4001                 :        160 :         free_INSN_LIST_list (&reg_last->control_uses);
    4002                 :  272501000 :       if (reg_last->clobbers)
    4003                 :   74403800 :         free_INSN_LIST_list (&reg_last->clobbers);
    4004                 :            :     }
    4005                 :    6532340 :   CLEAR_REG_SET (&deps->reg_last_in_use);
    4006                 :            : 
    4007                 :            :   /* As we initialize reg_last lazily, it is possible that we didn't allocate
    4008                 :            :      it at all.  */
    4009                 :    6532340 :   free (deps->reg_last);
    4010                 :    6532340 :   deps->reg_last = NULL;
    4011                 :            : 
    4012                 :    6532340 :   deps = NULL;
    4013                 :            : }
    4014                 :            : 
    4015                 :            : /* Remove INSN from dependence contexts DEPS.  */
    4016                 :            : void
    4017                 :       2361 : remove_from_deps (class deps_desc *deps, rtx_insn *insn)
    4018                 :            : {
    4019                 :       2361 :   int removed;
    4020                 :       2361 :   unsigned i;
    4021                 :       2361 :   reg_set_iterator rsi;
    4022                 :            : 
    4023                 :       2361 :   removed = remove_from_both_dependence_lists (insn, &deps->pending_read_insns,
    4024                 :            :                                                &deps->pending_read_mems);
    4025                 :       2361 :   if (!DEBUG_INSN_P (insn))
    4026                 :       2300 :     deps->pending_read_list_length -= removed;
    4027                 :       2361 :   removed = remove_from_both_dependence_lists (insn, &deps->pending_write_insns,
    4028                 :            :                                                &deps->pending_write_mems);
    4029                 :       2361 :   deps->pending_write_list_length -= removed;
    4030                 :            : 
    4031                 :       2361 :   removed = remove_from_dependence_list (insn, &deps->pending_jump_insns);
    4032                 :       2361 :   deps->pending_flush_length -= removed;
    4033                 :       2361 :   removed = remove_from_dependence_list (insn, &deps->last_pending_memory_flush);
    4034                 :       2361 :   deps->pending_flush_length -= removed;
    4035                 :            : 
    4036                 :       2361 :   unsigned to_clear = -1U;
    4037                 :      42343 :   EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
    4038                 :            :     {
    4039                 :      39982 :       if (to_clear != -1U)
    4040                 :            :         {
    4041                 :       7163 :           CLEAR_REGNO_REG_SET (&deps->reg_last_in_use, to_clear);
    4042                 :       7163 :           to_clear = -1U;
    4043                 :            :         }
    4044                 :      39982 :       struct deps_reg *reg_last = &deps->reg_last[i];
    4045                 :      39982 :       if (reg_last->uses)
    4046                 :       8150 :         remove_from_dependence_list (insn, &reg_last->uses);
    4047                 :      39982 :       if (reg_last->sets)
    4048                 :      14296 :         remove_from_dependence_list (insn, &reg_last->sets);
    4049                 :      39982 :       if (reg_last->implicit_sets)
    4050                 :        527 :         remove_from_dependence_list (insn, &reg_last->implicit_sets);
    4051                 :      39982 :       if (reg_last->clobbers)
    4052                 :      19788 :         remove_from_dependence_list (insn, &reg_last->clobbers);
    4053                 :      39982 :       if (!reg_last->uses && !reg_last->sets && !reg_last->implicit_sets
    4054                 :      22317 :           && !reg_last->clobbers)
    4055                 :       7494 :         to_clear = i;
    4056                 :            :     }
    4057                 :       2361 :   if (to_clear != -1U)
    4058                 :        331 :     CLEAR_REGNO_REG_SET (&deps->reg_last_in_use, to_clear);
    4059                 :            : 
    4060                 :       2361 :   if (CALL_P (insn))
    4061                 :            :     {
    4062                 :         76 :       remove_from_dependence_list (insn, &deps->last_function_call);
    4063                 :         76 :       remove_from_dependence_list (insn,
    4064                 :            :                                    &deps->last_function_call_may_noreturn);
    4065                 :            :     }
    4066                 :       2361 :   remove_from_dependence_list (insn, &deps->sched_before_next_call);
    4067                 :       2361 : }
    4068                 :            : 
    4069                 :            : /* Init deps data vector.  */
    4070                 :            : static void
    4071                 :     649435 : init_deps_data_vector (void)
    4072                 :            : {
    4073                 :     649435 :   int reserve = (sched_max_luid + 1 - h_d_i_d.length ());
    4074                 :     649907 :   if (reserve > 0 && ! h_d_i_d.space (reserve))
    4075                 :     645667 :     h_d_i_d.safe_grow_cleared (3 * sched_max_luid / 2);
    4076                 :     649435 : }
    4077                 :            : 
    4078                 :            : /* If it is profitable to use them, initialize or extend (depending on
    4079                 :            :    GLOBAL_P) dependency data.  */
    4080                 :            : void
    4081                 :     649435 : sched_deps_init (bool global_p)
    4082                 :            : {
    4083                 :            :   /* Average number of insns in the basic block.
    4084                 :            :      '+ 1' is used to make it nonzero.  */
    4085                 :     649435 :   int insns_in_block = sched_max_luid / n_basic_blocks_for_fn (cfun) + 1;
    4086                 :            : 
    4087                 :     649435 :   init_deps_data_vector ();
    4088                 :            : 
    4089                 :            :   /* We use another caching mechanism for selective scheduling, so
    4090                 :            :      we don't use this one.  */
    4091                 :     649435 :   if (!sel_sched_p () && global_p && insns_in_block > 100 * 5)
    4092                 :            :     {
    4093                 :            :       /* ?!? We could save some memory by computing a per-region luid mapping
    4094                 :            :          which could reduce both the number of vectors in the cache and the
    4095                 :            :          size of each vector.  Instead we just avoid the cache entirely unless
    4096                 :            :          the average number of instructions in a basic block is very high.  See
    4097                 :            :          the comment before the declaration of true_dependency_cache for
    4098                 :            :          what we consider "very high".  */
    4099                 :         46 :       cache_size = 0;
    4100                 :         46 :       extend_dependency_caches (sched_max_luid, true);
    4101                 :            :     }
    4102                 :            : 
    4103                 :     649435 :   if (global_p)
    4104                 :            :     {
    4105                 :     644653 :       dl_pool = new object_allocator<_deps_list> ("deps_list");
    4106                 :            :                                 /* Allocate lists for one block at a time.  */
    4107                 :     644653 :       dn_pool = new object_allocator<_dep_node> ("dep_node");
    4108                 :            :                                 /* Allocate nodes for one block at a time.  */
    4109                 :            :     }
    4110                 :     649435 : }
    4111                 :            : 
    4112                 :            : 
    4113                 :            : /* Create or extend (depending on CREATE_P) dependency caches to
    4114                 :            :    size N.  */
    4115                 :            : void
    4116                 :         46 : extend_dependency_caches (int n, bool create_p)
    4117                 :            : {
    4118                 :         46 :   if (create_p || true_dependency_cache)
    4119                 :            :     {
    4120                 :         46 :       int i, luid = cache_size + n;
    4121                 :            : 
    4122                 :         46 :       true_dependency_cache = XRESIZEVEC (bitmap_head, true_dependency_cache,
    4123                 :            :                                           luid);
    4124                 :         46 :       output_dependency_cache = XRESIZEVEC (bitmap_head,
    4125                 :            :                                             output_dependency_cache, luid);
    4126                 :         46 :       anti_dependency_cache = XRESIZEVEC (bitmap_head, anti_dependency_cache,
    4127                 :            :                                           luid);
    4128                 :         46 :       control_dependency_cache = XRESIZEVEC (bitmap_head, control_dependency_cache,
    4129                 :            :                                           luid);
    4130                 :            : 
    4131                 :         46 :       if (current_sched_info->flags & DO_SPECULATION)
    4132                 :          0 :         spec_dependency_cache = XRESIZEVEC (bitmap_head, spec_dependency_cache,
    4133                 :            :                                             luid);
    4134                 :            : 
    4135                 :     282561 :       for (i = cache_size; i < luid; i++)
    4136                 :            :         {
    4137                 :     282515 :           bitmap_initialize (&true_dependency_cache[i], 0);
    4138                 :     282515 :           bitmap_initialize (&output_dependency_cache[i], 0);
    4139                 :     282515 :           bitmap_initialize (&anti_dependency_cache[i], 0);
    4140                 :     282515 :           bitmap_initialize (&control_dependency_cache[i], 0);
    4141                 :            : 
    4142                 :     282515 :           if (current_sched_info->flags & DO_SPECULATION)
    4143                 :     282515 :             bitmap_initialize (&spec_dependency_cache[i], 0);
    4144                 :            :         }
    4145                 :         46 :       cache_size = luid;
    4146                 :            :     }
    4147                 :         46 : }
    4148                 :            : 
    4149                 :            : /* Finalize dependency information for the whole function.  */
    4150                 :            : void
    4151                 :     644653 : sched_deps_finish (void)
    4152                 :            : {
    4153                 :     644653 :   gcc_assert (deps_pools_are_empty_p ());
    4154                 :    1289310 :   delete dn_pool;
    4155                 :    1289310 :   delete dl_pool;
    4156                 :     644653 :   dn_pool = NULL;
    4157                 :     644653 :   dl_pool = NULL;
    4158                 :            : 
    4159                 :     644653 :   h_d_i_d.release ();
    4160                 :     644653 :   cache_size = 0;
    4161                 :            : 
    4162                 :     644653 :   if (true_dependency_cache)
    4163                 :            :     {
    4164                 :            :       int i;
    4165                 :            : 
    4166                 :         46 :       for (i = 0; i < cache_size; i++)
    4167                 :            :         {
    4168                 :            :           bitmap_clear (&true_dependency_cache[i]);
    4169                 :            :           bitmap_clear (&output_dependency_cache[i]);
    4170                 :            :           bitmap_clear (&anti_dependency_cache[i]);
    4171                 :            :           bitmap_clear (&control_dependency_cache[i]);
    4172                 :            : 
    4173                 :            :           if (sched_deps_info->generate_spec_deps)
    4174                 :            :             bitmap_clear (&spec_dependency_cache[i]);
    4175                 :            :         }
    4176                 :         46 :       free (true_dependency_cache);
    4177                 :         46 :       true_dependency_cache = NULL;
    4178                 :         46 :       free (output_dependency_cache);
    4179                 :         46 :       output_dependency_cache = NULL;
    4180                 :         46 :       free (anti_dependency_cache);
    4181                 :         46 :       anti_dependency_cache = NULL;
    4182                 :         46 :       free (control_dependency_cache);
    4183                 :         46 :       control_dependency_cache = NULL;
    4184                 :            : 
    4185                 :         46 :       if (sched_deps_info->generate_spec_deps)
    4186                 :            :         {
    4187                 :          0 :           free (spec_dependency_cache);
    4188                 :          0 :           spec_dependency_cache = NULL;
    4189                 :            :         }
    4190                 :            : 
    4191                 :            :     }
    4192                 :     644653 : }
    4193                 :            : 
    4194                 :            : /* Initialize some global variables needed by the dependency analysis
    4195                 :            :    code.  */
    4196                 :            : 
    4197                 :            : void
    4198                 :    6526040 : init_deps_global (void)
    4199                 :            : {
    4200                 :    6526040 :   CLEAR_HARD_REG_SET (implicit_reg_pending_clobbers);
    4201                 :   19578100 :   CLEAR_HARD_REG_SET (implicit_reg_pending_uses);
    4202                 :    6526040 :   reg_pending_sets = ALLOC_REG_SET (&reg_obstack);
    4203                 :    6526040 :   reg_pending_clobbers = ALLOC_REG_SET (&reg_obstack);
    4204                 :    6526040 :   reg_pending_uses = ALLOC_REG_SET (&reg_obstack);
    4205                 :    6526040 :   reg_pending_control_uses = ALLOC_REG_SET (&reg_obstack);
    4206                 :    6526040 :   reg_pending_barrier = NOT_A_BARRIER;
    4207                 :            : 
    4208                 :    6526040 :   if (!sel_sched_p () || sched_emulate_haifa_p)
    4209                 :            :     {
    4210                 :    6525370 :       sched_deps_info->start_insn = haifa_start_insn;
    4211                 :    6525370 :       sched_deps_info->finish_insn = haifa_finish_insn;
    4212                 :            : 
    4213                 :    6525370 :       sched_deps_info->note_reg_set = haifa_note_reg_set;
    4214                 :    6525370 :       sched_deps_info->note_reg_clobber = haifa_note_reg_clobber;
    4215                 :    6525370 :       sched_deps_info->note_reg_use = haifa_note_reg_use;
    4216                 :            : 
    4217                 :    6525370 :       sched_deps_info->note_mem_dep = haifa_note_mem_dep;
    4218                 :    6525370 :       sched_deps_info->note_dep = haifa_note_dep;
    4219                 :            :    }
    4220                 :    6526040 : }
    4221                 :            : 
    4222                 :            : /* Free everything used by the dependency analysis code.  */
    4223                 :            : 
    4224                 :            : void
    4225                 :    6526040 : finish_deps_global (void)
    4226                 :            : {
    4227                 :    6526040 :   FREE_REG_SET (reg_pending_sets);
    4228                 :    6526040 :   FREE_REG_SET (reg_pending_clobbers);
    4229                 :    6526040 :   FREE_REG_SET (reg_pending_uses);
    4230                 :    6526040 :   FREE_REG_SET (reg_pending_control_uses);
    4231                 :    6526040 : }
    4232                 :            : 
    4233                 :            : /* Estimate the weakness of dependence between MEM1 and MEM2.  */
    4234                 :            : dw_t
    4235                 :        542 : estimate_dep_weak (rtx mem1, rtx mem2)
    4236                 :            : {
    4237                 :        542 :   if (mem1 == mem2)
    4238                 :            :     /* MEMs are the same - don't speculate.  */
    4239                 :            :     return MIN_DEP_WEAK;
    4240                 :            : 
    4241                 :        542 :   rtx r1 = XEXP (mem1, 0);
    4242                 :        542 :   rtx r2 = XEXP (mem2, 0);
    4243                 :            : 
    4244                 :        542 :   if (sched_deps_info->use_cselib)
    4245                 :            :     {
    4246                 :            :       /* We cannot call rtx_equal_for_cselib_p because the VALUEs might be
    4247                 :            :          dangling at this point, since we never preserve them.  Instead we
    4248                 :            :          canonicalize manually to get stable VALUEs out of hashing.  */
    4249                 :          0 :       if (GET_CODE (r1) == VALUE && CSELIB_VAL_PTR (r1))
    4250                 :          0 :         r1 = canonical_cselib_val (CSELIB_VAL_PTR (r1))->val_rtx;
    4251                 :          0 :       if (GET_CODE (r2) == VALUE && CSELIB_VAL_PTR (r2))
    4252                 :          0 :         r2 = canonical_cselib_val (CSELIB_VAL_PTR (r2))->val_rtx;
    4253                 :            :     }
    4254                 :            : 
    4255                 :        542 :   if (r1 == r2
    4256                 :        542 :       || (REG_P (r1) && REG_P (r2) && REGNO (r1) == REGNO (r2)))
    4257                 :            :     /* Again, MEMs are the same.  */
    4258                 :            :     return MIN_DEP_WEAK;
    4259                 :        519 :   else if ((REG_P (r1) && !REG_P (r2)) || (!REG_P (r1) && REG_P (r2)))
    4260                 :            :     /* Different addressing modes - reason to be more speculative,
    4261                 :            :        than usual.  */
    4262                 :            :     return NO_DEP_WEAK - (NO_DEP_WEAK - UNCERTAIN_DEP_WEAK) / 2;
    4263                 :            :   else
    4264                 :            :     /* We can't say anything about the dependence.  */
    4265                 :        471 :     return UNCERTAIN_DEP_WEAK;
    4266                 :            : }
    4267                 :            : 
    4268                 :            : /* Add or update backward dependence between INSN and ELEM with type DEP_TYPE.
    4269                 :            :    This function can handle same INSN and ELEM (INSN == ELEM).
    4270                 :            :    It is a convenience wrapper.  */
    4271                 :            : static void
    4272                 :  378473000 : add_dependence_1 (rtx_insn *insn, rtx_insn *elem, enum reg_note dep_type)
    4273                 :            : {
    4274                 :  378473000 :   ds_t ds;
    4275                 :  378473000 :   bool internal;
    4276                 :            : 
    4277                 :  378473000 :   if (dep_type == REG_DEP_TRUE)
    4278                 :            :     ds = DEP_TRUE;
    4279                 :  304195000 :   else if (dep_type == REG_DEP_OUTPUT)
    4280                 :            :     ds = DEP_OUTPUT;
    4281                 :  255319000 :   else if (dep_type == REG_DEP_CONTROL)
    4282                 :            :     ds = DEP_CONTROL;
    4283                 :            :   else
    4284                 :            :     {
    4285                 :  255319000 :       gcc_assert (dep_type == REG_DEP_ANTI);
    4286                 :            :       ds = DEP_ANTI;
    4287                 :            :     }
    4288                 :            : 
    4289                 :            :   /* When add_dependence is called from inside sched-deps.c, we expect
    4290                 :            :      cur_insn to be non-null.  */
    4291                 :  378473000 :   internal = cur_insn != NULL;
    4292                 :  378473000 :   if (internal)
    4293                 :  341661000 :     gcc_assert (insn == cur_insn);
    4294                 :            :   else
    4295                 :   36812300 :     cur_insn = insn;
    4296                 :            : 
    4297                 :  378473000 :   note_dep (elem, ds);
    4298                 :  378473000 :   if (!internal)
    4299                 :   36812300 :     cur_insn = NULL;
    4300                 :  378473000 : }
    4301                 :            : 
    4302                 :            : /* Return weakness of speculative type TYPE in the dep_status DS,
    4303                 :            :    without checking to prevent ICEs on malformed input.  */
    4304                 :            : static dw_t
    4305                 :          0 : get_dep_weak_1 (ds_t ds, ds_t type)
    4306                 :            : {
    4307                 :          0 :   ds = ds & type;
    4308                 :            : 
    4309                 :          0 :   switch (type)
    4310                 :            :     {
    4311                 :            :     case BEGIN_DATA: ds >>= BEGIN_DATA_BITS_OFFSET; break;
    4312                 :          0 :     case BE_IN_DATA: ds >>= BE_IN_DATA_BITS_OFFSET; break;
    4313                 :          0 :     case BEGIN_CONTROL: ds >>= BEGIN_CONTROL_BITS_OFFSET; break;
    4314                 :          0 :     case BE_IN_CONTROL: ds >>= BE_IN_CONTROL_BITS_OFFSET; break;
    4315                 :          0 :     default: gcc_unreachable ();
    4316                 :            :     }
    4317                 :            : 
    4318                 :          0 :   return (dw_t) ds;
    4319                 :            : }
    4320                 :            : 
    4321                 :            : /* Return weakness of speculative type TYPE in the dep_status DS.  */
    4322                 :            : dw_t
    4323                 :          0 : get_dep_weak (ds_t ds, ds_t type)
    4324                 :            : {
    4325                 :          0 :   dw_t dw = get_dep_weak_1 (ds, type);
    4326                 :            : 
    4327                 :          0 :   gcc_assert (MIN_DEP_WEAK <= dw && dw <= MAX_DEP_WEAK);
    4328                 :          0 :   return dw;
    4329                 :            : }
    4330                 :            : 
    4331                 :            : /* Return the dep_status, which has the same parameters as DS, except for
    4332                 :            :    speculative type TYPE, that will have weakness DW.  */
    4333                 :            : ds_t
    4334                 :          0 : set_dep_weak (ds_t ds, ds_t type, dw_t dw)
    4335                 :            : {
    4336                 :          0 :   gcc_assert (MIN_DEP_WEAK <= dw && dw <= MAX_DEP_WEAK);
    4337                 :            : 
    4338                 :          0 :   ds &= ~type;
    4339                 :          0 :   switch (type)
    4340                 :            :     {
    4341                 :          0 :     case BEGIN_DATA: ds |= ((ds_t) dw) << BEGIN_DATA_BITS_OFFSET; break;
    4342                 :          0 :     case BE_IN_DATA: ds |= ((ds_t) dw) << BE_IN_DATA_BITS_OFFSET; break;
    4343                 :          0 :     case BEGIN_CONTROL: ds |= ((ds_t) dw) << BEGIN_CONTROL_BITS_OFFSET; break;
    4344                 :          0 :     case BE_IN_CONTROL: ds |= ((ds_t) dw) << BE_IN_CONTROL_BITS_OFFSET; break;
    4345                 :          0 :     default: gcc_unreachable ();
    4346                 :            :     }
    4347                 :          0 :   return ds;
    4348                 :            : }
    4349                 :            : 
    4350                 :            : /* Return the join of two dep_statuses DS1 and DS2.
    4351                 :            :    If MAX_P is true then choose the greater probability,
    4352                 :            :    otherwise multiply probabilities.
    4353                 :            :    This function assumes that both DS1 and DS2 contain speculative bits.  */
    4354                 :            : static ds_t
    4355                 :          0 : ds_merge_1 (ds_t ds1, ds_t ds2, bool max_p)
    4356                 :            : {
    4357                 :          0 :   ds_t ds, t;
    4358                 :            : 
    4359                 :          0 :   gcc_assert ((ds1 & SPECULATIVE) && (ds2 & SPECULATIVE));
    4360                 :            : 
    4361                 :          0 :   ds = (ds1 & DEP_TYPES) | (ds2 & DEP_TYPES);
    4362                 :            : 
    4363                 :          0 :   t = FIRST_SPEC_TYPE;
    4364                 :          0 :   do
    4365                 :            :     {
    4366                 :          0 :       if ((ds1 & t) && !(ds2 & t))
    4367                 :          0 :         ds |= ds1 & t;
    4368                 :          0 :       else if (!(ds1 & t) && (ds2 & t))
    4369                 :          0 :         ds |= ds2 & t;
    4370                 :          0 :       else if ((ds1 & t) && (ds2 & t))
    4371                 :            :         {
    4372                 :          0 :           dw_t dw1 = get_dep_weak (ds1, t);
    4373                 :          0 :           dw_t dw2 = get_dep_weak (ds2, t);
    4374                 :          0 :           ds_t dw;
    4375                 :            : 
    4376                 :          0 :           if (!max_p)
    4377                 :            :             {
    4378                 :          0 :               dw = ((ds_t) dw1) * ((ds_t) dw2);
    4379                 :          0 :               dw /= MAX_DEP_WEAK;
    4380                 :          0 :               if (dw < MIN_DEP_WEAK)
    4381                 :          0 :                 dw = MIN_DEP_WEAK;
    4382                 :            :             }
    4383                 :            :           else
    4384                 :            :             {
    4385                 :          0 :               if (dw1 >= dw2)
    4386                 :            :                 dw = dw1;
    4387                 :            :               else
    4388                 :            :                 dw = dw2;
    4389                 :            :             }
    4390                 :            : 
    4391                 :          0 :           ds = set_dep_weak (ds, t, (dw_t) dw);
    4392                 :            :         }
    4393                 :            : 
    4394                 :          0 :       if (t == LAST_SPEC_TYPE)
    4395                 :            :         break;
    4396                 :          0 :       t <<= SPEC_TYPE_SHIFT;
    4397                 :            :     }
    4398                 :            :   while (1);
    4399                 :            : 
    4400                 :          0 :   return ds;
    4401                 :            : }
    4402                 :            : 
    4403                 :            : /* Return the join of two dep_statuses DS1 and DS2.
    4404                 :            :    This function assumes that both DS1 and DS2 contain speculative bits.  */
    4405                 :            : ds_t
    4406                 :          0 : ds_merge (ds_t ds1, ds_t ds2)
    4407                 :            : {
    4408                 :          0 :   return ds_merge_1 (ds1, ds2, false);
    4409                 :            : }
    4410                 :            : 
    4411                 :            : /* Return the join of two dep_statuses DS1 and DS2.  */
    4412                 :            : ds_t
    4413                 :      64650 : ds_full_merge (ds_t ds, ds_t ds2, rtx mem1, rtx mem2)
    4414                 :            : {
    4415                 :      64650 :   ds_t new_status = ds | ds2;
    4416                 :            : 
    4417                 :      64650 :   if (new_status & SPECULATIVE)
    4418                 :            :     {
    4419                 :          0 :       if ((ds && !(ds & SPECULATIVE))
    4420                 :          0 :           || (ds2 && !(ds2 & SPECULATIVE)))
    4421                 :            :         /* Then this dep can't be speculative.  */
    4422                 :          0 :         new_status &= ~SPECULATIVE;
    4423                 :            :       else
    4424                 :            :         {
    4425                 :            :           /* Both are speculative.  Merging probabilities.  */
    4426                 :          0 :           if (mem1)
    4427                 :            :             {
    4428                 :          0 :               dw_t dw;
    4429                 :            : 
    4430                 :          0 :               dw = estimate_dep_weak (mem1, mem2);
    4431                 :          0 :               ds = set_dep_weak (ds, BEGIN_DATA, dw);
    4432                 :            :             }
    4433                 :            : 
    4434                 :          0 :           if (!ds)
    4435                 :            :             new_status = ds2;
    4436                 :          0 :           else if (!ds2)
    4437                 :            :             new_status = ds;
    4438                 :            :           else
    4439                 :          0 :             new_status = ds_merge (ds2, ds);
    4440                 :            :         }
    4441                 :            :     }
    4442                 :            : 
    4443                 :      64650 :   return new_status;
    4444                 :            : }
    4445                 :            : 
    4446                 :            : /* Return the join of DS1 and DS2.  Use maximum instead of multiplying
    4447                 :            :    probabilities.  */
    4448                 :            : ds_t
    4449                 :       3046 : ds_max_merge (ds_t ds1, ds_t ds2)
    4450                 :            : {
    4451                 :       3046 :   if (ds1 == 0 && ds2 == 0)
    4452                 :            :     return 0;
    4453                 :            : 
    4454                 :          0 :   if (ds1 == 0 && ds2 != 0)
    4455                 :            :     return ds2;
    4456                 :            : 
    4457                 :          0 :   if (ds1 != 0 && ds2 == 0)
    4458                 :            :     return ds1;
    4459                 :            : 
    4460                 :          0 :   return ds_merge_1 (ds1, ds2, true);
    4461                 :            : }
    4462                 :            : 
    4463                 :            : /* Return the probability of speculation success for the speculation
    4464                 :            :    status DS.  */
    4465                 :            : dw_t
    4466                 :          0 : ds_weak (ds_t ds)
    4467                 :            : {
    4468                 :          0 :   ds_t res = 1, dt;
    4469                 :          0 :   int n = 0;
    4470                 :            : 
    4471                 :          0 :   dt = FIRST_SPEC_TYPE;
    4472                 :          0 :   do
    4473                 :            :     {
    4474                 :          0 :       if (ds & dt)
    4475                 :            :         {
    4476                 :          0 :           res *= (ds_t) get_dep_weak (ds, dt);
    4477                 :          0 :           n++;
    4478                 :            :         }
    4479                 :            : 
    4480                 :          0 :       if (dt == LAST_SPEC_TYPE)
    4481                 :            :         break;
    4482                 :          0 :       dt <<= SPEC_TYPE_SHIFT;
    4483                 :            :     }
    4484                 :            :   while (1);
    4485                 :            : 
    4486                 :          0 :   gcc_assert (n);
    4487                 :          0 :   while (--n)
    4488                 :          0 :     res /= MAX_DEP_WEAK;
    4489                 :            : 
    4490                 :          0 :   if (res < MIN_DEP_WEAK)
    4491                 :            :     res = MIN_DEP_WEAK;
    4492                 :            : 
    4493                 :          0 :   gcc_assert (res <= MAX_DEP_WEAK);
    4494                 :            : 
    4495                 :          0 :   return (dw_t) res;
    4496                 :            : }
    4497                 :            : 
    4498                 :            : /* Return a dep status that contains all speculation types of DS.  */
    4499                 :            : ds_t
    4500                 :       5134 : ds_get_speculation_types (ds_t ds)
    4501                 :            : {
    4502                 :       5134 :   if (ds & BEGIN_DATA)
    4503                 :          0 :     ds |= BEGIN_DATA;
    4504                 :       5134 :   if (ds & BE_IN_DATA)
    4505                 :          0 :     ds |= BE_IN_DATA;
    4506                 :       5134 :   if (ds & BEGIN_CONTROL)
    4507                 :          0 :     ds |= BEGIN_CONTROL;
    4508                 :       5134 :   if (ds & BE_IN_CONTROL)
    4509                 :          0 :     ds |= BE_IN_CONTROL;
    4510                 :            : 
    4511                 :       5134 :   return ds & SPECULATIVE;
    4512                 :            : }
    4513                 :            : 
    4514                 :            : /* Return a dep status that contains maximal weakness for each speculation
    4515                 :            :    type present in DS.  */
    4516                 :            : ds_t
    4517                 :       2591 : ds_get_max_dep_weak (ds_t ds)
    4518                 :            : {
    4519                 :       2591 :   if (ds & BEGIN_DATA)
    4520                 :          0 :     ds = set_dep_weak (ds, BEGIN_DATA, MAX_DEP_WEAK);
    4521                 :       2591 :   if (ds & BE_IN_DATA)
    4522                 :          0 :     ds = set_dep_weak (ds, BE_IN_DATA, MAX_DEP_WEAK);
    4523                 :       2591 :   if (ds & BEGIN_CONTROL)
    4524                 :          0 :     ds = set_dep_weak (ds, BEGIN_CONTROL, MAX_DEP_WEAK);
    4525                 :       2591 :   if (ds & BE_IN_CONTROL)
    4526                 :          0 :     ds = set_dep_weak (ds, BE_IN_CONTROL, MAX_DEP_WEAK);
    4527                 :            : 
    4528                 :       2591 :   return ds;
    4529                 :            : }
    4530                 :            : 
    4531                 :            : /* Dump information about the dependence status S.  */
    4532                 :            : static void
    4533                 :          0 : dump_ds (FILE *f, ds_t s)
    4534                 :            : {
    4535                 :          0 :   fprintf (f, "{");
    4536                 :            : 
    4537                 :          0 :   if (s & BEGIN_DATA)
    4538                 :          0 :     fprintf (f, "BEGIN_DATA: %d; ", get_dep_weak_1 (s, BEGIN_DATA));
    4539                 :          0 :   if (s & BE_IN_DATA)
    4540                 :          0 :     fprintf (f, "BE_IN_DATA: %d; ", get_dep_weak_1 (s, BE_IN_DATA));
    4541                 :          0 :   if (s & BEGIN_CONTROL)
    4542                 :          0 :     fprintf (f, "BEGIN_CONTROL: %d; ", get_dep_weak_1 (s, BEGIN_CONTROL));
    4543                 :          0 :   if (s & BE_IN_CONTROL)
    4544                 :          0 :     fprintf (f, "BE_IN_CONTROL: %d; ", get_dep_weak_1 (s, BE_IN_CONTROL));
    4545                 :            : 
    4546                 :          0 :   if (s & HARD_DEP)
    4547                 :          0 :     fprintf (f, "HARD_DEP; ");
    4548                 :            : 
    4549                 :          0 :   if (s & DEP_TRUE)
    4550                 :          0 :     fprintf (f, "DEP_TRUE; ");
    4551                 :          0 :   if (s & DEP_OUTPUT)
    4552                 :          0 :     fprintf (f, "DEP_OUTPUT; ");
    4553                 :          0 :   if (s & DEP_ANTI)
    4554                 :          0 :     fprintf (f, "DEP_ANTI; ");
    4555                 :          0 :   if (s & DEP_CONTROL)
    4556                 :          0 :     fprintf (f, "DEP_CONTROL; ");
    4557                 :            : 
    4558                 :          0 :   fprintf (f, "}");
    4559                 :          0 : }
    4560                 :            : 
    4561                 :            : DEBUG_FUNCTION void
    4562                 :          0 : debug_ds (ds_t s)
    4563                 :            : {
    4564                 :          0 :   dump_ds (stderr, s);
    4565                 :          0 :   fprintf (stderr, "\n");
    4566                 :          0 : }
    4567                 :            : 
    4568                 :            : /* Verify that dependence type and status are consistent.
    4569                 :            :    If RELAXED_P is true, then skip dep_weakness checks.  */
    4570                 :            : static void
    4571                 :  475568000 : check_dep (dep_t dep, bool relaxed_p)
    4572                 :            : {
    4573                 :  475568000 :   enum reg_note dt = DEP_TYPE (dep);
    4574                 :  475568000 :   ds_t ds = DEP_STATUS (dep);
    4575                 :            : 
    4576                 :  475568000 :   gcc_assert (DEP_PRO (dep) != DEP_CON (dep));
    4577                 :            : 
    4578                 :  475568000 :   if (!(current_sched_info->flags & USE_DEPS_LIST))
    4579                 :            :     {
    4580                 :  475568000 :       gcc_assert (ds == 0);
    4581                 :            :       return;
    4582                 :            :     }
    4583                 :            : 
    4584                 :            :   /* Check that dependence type contains the same bits as the status.  */
    4585                 :          0 :   if (dt == REG_DEP_TRUE)
    4586                 :          0 :     gcc_assert (ds & DEP_TRUE);
    4587                 :          0 :   else if (dt == REG_DEP_OUTPUT)
    4588                 :          0 :     gcc_assert ((ds & DEP_OUTPUT)
    4589                 :            :                 && !(ds & DEP_TRUE));
    4590                 :          0 :   else if (dt == REG_DEP_ANTI)
    4591                 :          0 :     gcc_assert ((ds & DEP_ANTI)
    4592                 :            :                 && !(ds & (DEP_OUTPUT | DEP_TRUE)));
    4593                 :            :   else
    4594                 :          0 :     gcc_assert (dt == REG_DEP_CONTROL
    4595                 :            :                 && (ds & DEP_CONTROL)
    4596                 :            :                 && !(ds & (DEP_OUTPUT | DEP_ANTI | DEP_TRUE)));
    4597                 :            : 
    4598                 :            :   /* HARD_DEP cannot appear in dep_status of a link.  */
    4599                 :          0 :   gcc_assert (!(ds & HARD_DEP));
    4600                 :            : 
    4601                 :            :   /* Check that dependence status is set correctly when speculation is not
    4602                 :            :      supported.  */
    4603                 :          0 :   if (!sched_deps_info->generate_spec_deps)
    4604                 :          0 :     gcc_assert (!(ds & SPECULATIVE));
    4605                 :          0 :   else if (ds & SPECULATIVE)
    4606                 :            :     {
    4607                 :          0 :       if (!relaxed_p)
    4608                 :            :         {
    4609                 :            :           ds_t type = FIRST_SPEC_TYPE;
    4610                 :            : 
    4611                 :            :           /* Check that dependence weakness is in proper range.  */
    4612                 :          0 :           do
    4613                 :            :             {
    4614                 :          0 :               if (ds & type)
    4615                 :          0 :                 get_dep_weak (ds, type);
    4616                 :            : 
    4617                 :          0 :               if (type == LAST_SPEC_TYPE)
    4618                 :            :                 break;
    4619                 :          0 :               type <<= SPEC_TYPE_SHIFT;
    4620                 :            :             }
    4621                 :            :           while (1);
    4622                 :            :         }
    4623                 :            : 
    4624                 :          0 :       if (ds & BEGIN_SPEC)
    4625                 :            :         {
    4626                 :            :           /* Only true dependence can be data speculative.  */
    4627                 :          0 :           if (ds & BEGIN_DATA)
    4628                 :          0 :             gcc_assert (ds & DEP_TRUE);
    4629                 :            : 
    4630                 :            :           /* Control dependencies in the insn scheduler are represented by
    4631                 :            :              anti-dependencies, therefore only anti dependence can be
    4632                 :            :              control speculative.  */
    4633                 :          0 :           if (ds & BEGIN_CONTROL)
    4634                 :          0 :             gcc_assert (ds & DEP_ANTI);
    4635                 :            :         }
    4636                 :            :       else
    4637                 :            :         {
    4638                 :            :           /* Subsequent speculations should resolve true dependencies.  */
    4639                 :          0 :           gcc_assert ((ds & DEP_TYPES) == DEP_TRUE);
    4640                 :            :         }
    4641                 :            : 
    4642                 :            :       /* Check that true and anti dependencies can't have other speculative
    4643                 :            :          statuses.  */
    4644                 :          0 :       if (ds & DEP_TRUE)
    4645                 :          0 :         gcc_assert (ds & (BEGIN_DATA | BE_IN_SPEC));
    4646                 :            :       /* An output dependence can't be speculative at all.  */
    4647                 :          0 :       gcc_assert (!(ds & DEP_OUTPUT));
    4648                 :          0 :       if (ds & DEP_ANTI)
    4649                 :          0 :         gcc_assert (ds & BEGIN_CONTROL);
    4650                 :            :     }
    4651                 :            : }
    4652                 :            : 
    4653                 :            : /* The following code discovers opportunities to switch a memory reference
    4654                 :            :    and an increment by modifying the address.  We ensure that this is done
    4655                 :            :    only for dependencies that are only used to show a single register
    4656                 :            :    dependence (using DEP_NONREG and DEP_MULTIPLE), and so that every memory
    4657                 :            :    instruction involved is subject to only one dep that can cause a pattern
    4658                 :            :    change.
    4659                 :            : 
    4660                 :            :    When we discover a suitable dependency, we fill in the dep_replacement
    4661                 :            :    structure to show how to modify the memory reference.  */
    4662                 :            : 
    4663                 :            : /* Holds information about a pair of memory reference and register increment
    4664                 :            :    insns which depend on each other, but could possibly be interchanged.  */
    4665                 :            : struct mem_inc_info
    4666                 :            : {
    4667                 :            :   rtx_insn *inc_insn;
    4668                 :            :   rtx_insn *mem_insn;
    4669                 :            : 
    4670                 :            :   rtx *mem_loc;
    4671                 :            :   /* A register occurring in the memory address for which we wish to break
    4672                 :            :      the dependence.  This must be identical to the destination register of
    4673                 :            :      the increment.  */
    4674                 :            :   rtx mem_reg0;
    4675                 :            :   /* Any kind of index that is added to that register.  */
    4676                 :            :   rtx mem_index;
    4677                 :            :   /* The constant offset used in the memory address.  */
    4678                 :            :   HOST_WIDE_INT mem_constant;
    4679                 :            :   /* The constant added in the increment insn.  Negated if the increment is
    4680                 :            :      after the memory address.  */
    4681                 :            :   HOST_WIDE_INT inc_constant;
    4682                 :            :   /* The source register used in the increment.  May be different from mem_reg0
    4683                 :            :      if the increment occurs before the memory address.  */
    4684                 :            :   rtx inc_input;
    4685                 :            : };
    4686                 :            : 
    4687                 :            : /* Verify that the memory location described in MII can be replaced with
    4688                 :            :    one using NEW_ADDR.  Return the new memory reference or NULL_RTX.  The
    4689                 :            :    insn remains unchanged by this function.  */
    4690                 :            : 
    4691                 :            : static rtx
    4692                 :     648182 : attempt_change (struct mem_inc_info *mii, rtx new_addr)
    4693                 :            : {
    4694                 :     648182 :   rtx mem = *mii->mem_loc;
    4695                 :     648182 :   rtx new_mem;
    4696                 :            : 
    4697                 :            :   /* Jump through a lot of hoops to keep the attributes up to date.  We
    4698                 :            :      do not want to call one of the change address variants that take
    4699                 :            :      an offset even though we know the offset in many cases.  These
    4700                 :            :      assume you are changing where the address is pointing by the
    4701                 :            :      offset.  */
    4702                 :     648182 :   new_mem = replace_equiv_address_nv (mem, new_addr);
    4703                 :     648182 :   if (! validate_change (mii->mem_insn, mii->mem_loc, new_mem, 0))
    4704                 :            :     {
    4705                 :          2 :       if (sched_verbose >= 5)
    4706                 :          0 :         fprintf (sched_dump, "validation failure\n");
    4707                 :          2 :       return NULL_RTX;
    4708                 :            :     }
    4709                 :            : 
    4710                 :            :   /* Put back the old one.  */
    4711                 :     648180 :   validate_change (mii->mem_insn, mii->mem_loc, mem, 0);
    4712                 :            : 
    4713                 :     648180 :   return new_mem;
    4714                 :            : }
    4715                 :            : 
    4716                 :            : /* Return true if INSN is of a form "a = b op c" where a and b are
    4717                 :            :    regs.  op is + if c is a reg and +|- if c is a const.  Fill in
    4718                 :            :    informantion in MII about what is found.
    4719                 :            :    BEFORE_MEM indicates whether the increment is found before or after
    4720                 :            :    a corresponding memory reference.  */
    4721                 :            : 
    4722                 :            : static bool
    4723                 :   22121700 : parse_add_or_inc (struct mem_inc_info *mii, rtx_insn *insn, bool before_mem)
    4724                 :            : {
    4725                 :   22121700 :   rtx pat = single_set (insn);
    4726                 :   22121700 :   rtx src, cst;
    4727                 :   22121700 :   bool regs_equal;
    4728                 :            : 
    4729                 :   22121700 :   if (RTX_FRAME_RELATED_P (insn) || !pat)
    4730                 :            :     return false;
    4731                 :            : 
    4732                 :            :   /* Do not allow breaking data dependencies for insns that are marked
    4733                 :            :      with REG_STACK_CHECK.  */
    4734                 :   18350800 :   if (find_reg_note (insn, REG_STACK_CHECK, NULL))
    4735                 :            :     return false;
    4736                 :            : 
    4737                 :            :   /* Result must be single reg.  */
    4738                 :   18350800 :   if (!REG_P (SET_DEST (pat)))
    4739                 :            :     return false;
    4740                 :            : 
    4741                 :   12773000 :   if (GET_CODE (SET_SRC (pat)) != PLUS)
    4742                 :            :     return false;
    4743                 :            : 
    4744                 :    3012310 :   mii->inc_insn = insn;
    4745                 :    3012310 :   src = SET_SRC (pat);
    4746                 :    3012310 :   mii->inc_input = XEXP (src, 0);
    4747                 :            : 
    4748                 :    3012310 :   if (!REG_P (XEXP (src, 0)))
    4749                 :            :     return false;
    4750                 :            : 
    4751                 :    2859090 :   if (!rtx_equal_p (SET_DEST (pat), mii->mem_reg0))
    4752                 :            :     return false;
    4753                 :            : 
    4754                 :    1826710 :   cst = XEXP (src, 1);
    4755                 :    1826710 :   if (!CONST_INT_P (cst))
    4756                 :            :     return false;
    4757                 :    1728050 :   mii->inc_constant = INTVAL (cst);
    4758                 :            : 
    4759                 :    1728050 :   regs_equal = rtx_equal_p (mii->inc_input, mii->mem_reg0);
    4760                 :            : 
    4761                 :    1728050 :   if (!before_mem)
    4762                 :            :     {
    4763                 :    1190800 :       mii->inc_constant = -mii->inc_constant;
    4764                 :    1190800 :       if (!regs_equal)
    4765                 :            :         return false;
    4766                 :            :     }
    4767                 :            : 
    4768                 :    1695270 :   if (regs_equal && REGNO (SET_DEST (pat)) == STACK_POINTER_REGNUM)
    4769                 :            :     {
    4770                 :            :       /* Note that the sign has already been reversed for !before_mem.  */
    4771                 :    1517180 :       if (STACK_GROWS_DOWNWARD)
    4772                 :    1517180 :         return mii->inc_constant > 0;
    4773                 :            :       else
    4774                 :            :         return mii->inc_constant < 0;
    4775                 :            :     }
    4776                 :            :   return true;
    4777                 :            : }
    4778                 :            : 
    4779                 :            : /* Once a suitable mem reference has been found and the corresponding data
    4780                 :            :    in MII has been filled in, this function is called to find a suitable
    4781                 :            :    add or inc insn involving the register we found in the memory
    4782                 :            :    reference.  */
    4783                 :            : 
    4784                 :            : static bool
    4785                 :   19932300 : find_inc (struct mem_inc_info *mii, bool backwards)
    4786                 :            : {
    4787                 :   19932300 :   sd_iterator_def sd_it;
    4788                 :   19932300 :   dep_t dep;
    4789                 :            : 
    4790                 :   19932300 :   sd_it = sd_iterator_start (mii->mem_insn,
    4791                 :   29822600 :                              backwards ? SD_LIST_HARD_BACK : SD_LIST_FORW);
    4792                 :   66201900 :   while (sd_iterator_cond (&sd_it, &dep))
    4793                 :            :     {
    4794                 :   46917700 :       dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
    4795                 :   46917700 :       rtx_insn *pro = DEP_PRO (dep);
    4796                 :   46917700 :       rtx_insn *con = DEP_CON (dep);
    4797                 :   46917700 :       rtx_insn *inc_cand = backwards ? pro : con;
    4798                 :   46917700 :       if (DEP_NONREG (dep) || DEP_MULTIPLE (dep))
    4799                 :   24796000 :         goto next;
    4800                 :   22121700 :       if (parse_add_or_inc (mii, inc_cand, backwards))
    4801                 :            :         {
    4802                 :     649279 :           struct dep_replacement *desc;
    4803                 :     649279 :           df_ref def;
    4804                 :     649279 :           rtx newaddr, newmem;
    4805                 :            : 
    4806                 :     649279 :           if (sched_verbose >= 5)
    4807                 :          0 :             fprintf (sched_dump, "candidate mem/inc pair: %d %d\n",
    4808                 :          0 :                      INSN_UID (mii->mem_insn), INSN_UID (inc_cand));
    4809                 :            : 
    4810                 :            :           /* Need to assure that none of the operands of the inc
    4811                 :            :              instruction are assigned to by the mem insn.  */
    4812                 :     886512 :           FOR_EACH_INSN_DEF (def, mii->mem_insn)
    4813                 :     238330 :             if (reg_overlap_mentioned_p (DF_REF_REG (def), mii->inc_input)
    4814                 :     238330 :                 || reg_overlap_mentioned_p (DF_REF_REG (def), mii->mem_reg0))
    4815                 :            :               {
    4816                 :       1097 :                 if (sched_verbose >= 5)
    4817                 :          0 :                   fprintf (sched_dump,
    4818                 :            :                            "inc conflicts with store failure.\n");
    4819                 :       1097 :                 goto next;
    4820                 :            :               }
    4821                 :            : 
    4822                 :     648182 :           newaddr = mii->inc_input;
    4823                 :     648182 :           if (mii->mem_index != NULL_RTX)
    4824                 :      15122 :             newaddr = gen_rtx_PLUS (GET_MODE (newaddr), newaddr,
    4825                 :            :                                     mii->mem_index);
    4826                 :    1296360 :           newaddr = plus_constant (GET_MODE (newaddr), newaddr,
    4827                 :     648182 :                                    mii->mem_constant + mii->inc_constant);
    4828                 :     648182 :           newmem = attempt_change (mii, newaddr);
    4829                 :     648182 :           if (newmem == NULL_RTX)
    4830                 :          2 :             goto next;
    4831                 :     648180 :           if (sched_verbose >= 5)
    4832                 :          0 :             fprintf (sched_dump, "successful address replacement\n");
    4833                 :     648180 :           desc = XCNEW (struct dep_replacement);
    4834                 :     648180 :           DEP_REPLACE (dep) = desc;
    4835                 :     648180 :           desc->loc = mii->mem_loc;
    4836                 :     648180 :           desc->newval = newmem;
    4837                 :     648180 :           desc->orig = *desc->loc;
    4838                 :     648180 :           desc->insn = mii->mem_insn;
    4839                 :     648180 :           move_dep_link (DEP_NODE_BACK (node), INSN_HARD_BACK_DEPS (con),
    4840                 :     648180 :                          INSN_SPEC_BACK_DEPS (con));
    4841                 :     648180 :           if (backwards)
    4842                 :            :             {
    4843                 :    1764290 :               FOR_EACH_DEP (mii->inc_insn, SD_LIST_BACK, sd_it, dep)
    4844                 :    1612500 :                 add_dependence_1 (mii->mem_insn, DEP_PRO (dep),
    4845                 :            :                                   REG_DEP_TRUE);
    4846                 :            :             }
    4847                 :            :           else
    4848                 :            :             {
    4849                 :    3749730 :               FOR_EACH_DEP (mii->inc_insn, SD_LIST_FORW, sd_it, dep)
    4850                 :    3253340 :                 add_dependence_1 (DEP_CON (dep), mii->mem_insn,
    4851                 :            :                                   REG_DEP_ANTI);
    4852                 :            :             }
    4853                 :     648180 :           return true;
    4854                 :            :         }
    4855                 :   21472400 :     next:
    4856                 :   46269500 :       sd_iterator_next (&sd_it);
    4857                 :            :     }
    4858                 :            :   return false;
    4859                 :            : }
    4860                 :            : 
    4861                 :            : /* A recursive function that walks ADDRESS_OF_X to find memory references
    4862                 :            :    which could be modified during scheduling.  We call find_inc for each
    4863                 :            :    one we find that has a recognizable form.  MII holds information about
    4864                 :            :    the pair of memory/increment instructions.
    4865                 :            :    We ensure that every instruction with a memory reference (which will be
    4866                 :            :    the location of the replacement) is assigned at most one breakable
    4867                 :            :    dependency.  */
    4868                 :            : 
    4869                 :            : static bool
    4870                 :  162441000 : find_mem (struct mem_inc_info *mii, rtx *address_of_x)
    4871                 :            : {
    4872                 :  162441000 :   rtx x = *address_of_x;
    4873                 :  162441000 :   enum rtx_code code = GET_CODE (x);
    4874                 :  162441000 :   const char *const fmt = GET_RTX_FORMAT (code);
    4875                 :  162441000 :   int i;
    4876                 :            : 
    4877                 :  162441000 :   if (code == MEM)
    4878                 :            :     {
    4879                 :   17802600 :       rtx reg0 = XEXP (x, 0);
    4880                 :            : 
    4881                 :   17802600 :       mii->mem_loc = address_of_x;
    4882                 :   17802600 :       mii->mem_index = NULL_RTX;
    4883                 :   17802600 :       mii->mem_constant = 0;
    4884                 :   17802600 :       if (GET_CODE (reg0) == PLUS && CONST_INT_P (XEXP (reg0, 1)))
    4885                 :            :         {
    4886                 :    8973680 :           mii->mem_constant = INTVAL (XEXP (reg0, 1));
    4887                 :    8973680 :           reg0 = XEXP (reg0, 0);
    4888                 :            :         }
    4889                 :   17802600 :       if (GET_CODE (reg0) == PLUS)
    4890                 :            :         {
    4891                 :     625699 :           mii->mem_index = XEXP (reg0, 1);
    4892                 :     625699 :           reg0 = XEXP (reg0, 0);
    4893                 :            :         }
    4894                 :   17802600 :       if (REG_P (reg0))
    4895                 :            :         {
    4896                 :   10704900 :           df_ref use;
    4897                 :   10704900 :           int occurrences = 0;
    4898                 :            : 
    4899                 :            :           /* Make sure this reg appears only once in this insn.  Can't use
    4900                 :            :              count_occurrences since that only works for pseudos.  */
    4901                 :   26285800 :           FOR_EACH_INSN_USE (use, mii->mem_insn)
    4902                 :   16243700 :             if (reg_overlap_mentioned_p (reg0, DF_REF_REG (use)))
    4903                 :   11367800 :               if (++occurrences > 1)
    4904                 :            :                 {
    4905                 :     662854 :                   if (sched_verbose >= 5)
    4906                 :          0 :                     fprintf (sched_dump, "mem count failure\n");
    4907                 :     662854 :                   return false;
    4908                 :            :                 }
    4909                 :            : 
    4910                 :   10042100 :           mii->mem_reg0 = reg0;
    4911                 :   10042100 :           return find_inc (mii, true) || find_inc (mii, false);
    4912                 :            :         }
    4913                 :            :       return false;
    4914                 :            :     }
    4915                 :            : 
    4916                 :  144638000 :   if (code == SIGN_EXTRACT || code == ZERO_EXTRACT)
    4917                 :            :     {
    4918                 :            :       /* If REG occurs inside a MEM used in a bit-field reference,
    4919                 :            :          that is unacceptable.  */
    4920                 :            :       return false;
    4921                 :            :     }
    4922                 :            : 
    4923                 :            :   /* Time for some deep diving.  */
    4924                 :  340354000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    4925                 :            :     {
    4926                 :  196424000 :       if (fmt[i] == 'e')
    4927                 :            :         {
    4928                 :  114600000 :           if (find_mem (mii, &XEXP (x, i)))
    4929                 :            :             return true;
    4930                 :            :         }
    4931                 :   81824800 :       else if (fmt[i] == 'E')
    4932                 :            :         {
    4933                 :    5660140 :           int j;
    4934                 :   16859700 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    4935                 :   11206400 :             if (find_mem (mii, &XVECEXP (x, i, j)))
    4936                 :            :               return true;
    4937                 :            :         }
    4938                 :            :     }
    4939                 :            :   return false;
    4940                 :            : }
    4941                 :            : 
    4942                 :            : 
    4943                 :            : /* Examine the instructions between HEAD and TAIL and try to find
    4944                 :            :    dependencies that can be broken by modifying one of the patterns.  */
    4945                 :            : 
    4946                 :            : void
    4947                 :    6519130 : find_modifiable_mems (rtx_insn *head, rtx_insn *tail)
    4948                 :            : {
    4949                 :    6519130 :   rtx_insn *insn, *next_tail = NEXT_INSN (tail);
    4950                 :    6519130 :   int success_in_block = 0;
    4951                 :            : 
    4952                 :  140505000 :   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
    4953                 :            :     {
    4954                 :   66992900 :       struct mem_inc_info mii;
    4955                 :            : 
    4956                 :   66992900 :       if (!NONDEBUG_INSN_P (insn) || RTX_FRAME_RELATED_P (insn))
    4957                 :   30358100 :         continue;
    4958                 :            : 
    4959                 :   36634800 :       mii.mem_insn = insn;
    4960                 :   36634800 :       if (find_mem (&mii, &PATTERN (insn)))
    4961                 :     648180 :         success_in_block++;
    4962                 :            :     }
    4963                 :    6519130 :   if (success_in_block && sched_verbose >= 5)
    4964                 :          0 :     fprintf (sched_dump, "%d candidates for address modification found.\n",
    4965                 :            :              success_in_block);
    4966                 :    6519130 : }
    4967                 :            : 
    4968                 :            : #endif /* INSN_SCHEDULING */

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.