LCOV - code coverage report
Current view: top level - gcc - ira-color.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1913 2625 72.9 %
Date: 2020-04-04 11:58:09 Functions: 76 109 69.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* IRA allocation based on graph coloring.
       2                 :            :    Copyright (C) 2006-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Vladimir Makarov <vmakarov@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "target.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "predict.h"
      29                 :            : #include "df.h"
      30                 :            : #include "memmodel.h"
      31                 :            : #include "tm_p.h"
      32                 :            : #include "insn-config.h"
      33                 :            : #include "regs.h"
      34                 :            : #include "ira.h"
      35                 :            : #include "ira-int.h"
      36                 :            : #include "reload.h"
      37                 :            : #include "cfgloop.h"
      38                 :            : 
      39                 :            : typedef struct allocno_hard_regs *allocno_hard_regs_t;
      40                 :            : 
      41                 :            : /* The structure contains information about hard registers can be
      42                 :            :    assigned to allocnos.  Usually it is allocno profitable hard
      43                 :            :    registers but in some cases this set can be a bit different.  Major
      44                 :            :    reason of the difference is a requirement to use hard register sets
      45                 :            :    that form a tree or a forest (set of trees), i.e. hard register set
      46                 :            :    of a node should contain hard register sets of its subnodes.  */
      47                 :            : struct allocno_hard_regs
      48                 :            : {
      49                 :            :   /* Hard registers can be assigned to an allocno.  */
      50                 :            :   HARD_REG_SET set;
      51                 :            :   /* Overall (spilling) cost of all allocnos with given register
      52                 :            :      set.  */
      53                 :            :   int64_t cost;
      54                 :            : };
      55                 :            : 
      56                 :            : typedef struct allocno_hard_regs_node *allocno_hard_regs_node_t;
      57                 :            : 
      58                 :            : /* A node representing allocno hard registers.  Such nodes form a
      59                 :            :    forest (set of trees).  Each subnode of given node in the forest
      60                 :            :    refers for hard register set (usually allocno profitable hard
      61                 :            :    register set) which is a subset of one referred from given
      62                 :            :    node.  */
      63                 :            : struct allocno_hard_regs_node
      64                 :            : {
      65                 :            :   /* Set up number of the node in preorder traversing of the forest.  */
      66                 :            :   int preorder_num;
      67                 :            :   /* Used for different calculation like finding conflict size of an
      68                 :            :      allocno.  */
      69                 :            :   int check;
      70                 :            :   /* Used for calculation of conflict size of an allocno.  The
      71                 :            :      conflict size of the allocno is maximal number of given allocno
      72                 :            :      hard registers needed for allocation of the conflicting allocnos.
      73                 :            :      Given allocno is trivially colored if this number plus the number
      74                 :            :      of hard registers needed for given allocno is not greater than
      75                 :            :      the number of given allocno hard register set.  */
      76                 :            :   int conflict_size;
      77                 :            :   /* The number of hard registers given by member hard_regs.  */
      78                 :            :   int hard_regs_num;
      79                 :            :   /* The following member is used to form the final forest.  */
      80                 :            :   bool used_p;
      81                 :            :   /* Pointer to the corresponding profitable hard registers.  */
      82                 :            :   allocno_hard_regs_t hard_regs;
      83                 :            :   /* Parent, first subnode, previous and next node with the same
      84                 :            :      parent in the forest.  */
      85                 :            :   allocno_hard_regs_node_t parent, first, prev, next;
      86                 :            : };
      87                 :            : 
      88                 :            : /* Info about changing hard reg costs of an allocno.  */
      89                 :            : struct update_cost_record
      90                 :            : {
      91                 :            :   /* Hard regno for which we changed the cost.  */
      92                 :            :   int hard_regno;
      93                 :            :   /* Divisor used when we changed the cost of HARD_REGNO.  */
      94                 :            :   int divisor;
      95                 :            :   /* Next record for given allocno.  */
      96                 :            :   struct update_cost_record *next;
      97                 :            : };
      98                 :            : 
      99                 :            : /* To decrease footprint of ira_allocno structure we store all data
     100                 :            :    needed only for coloring in the following structure.  */
     101                 :            : struct allocno_color_data
     102                 :            : {
     103                 :            :   /* TRUE value means that the allocno was not removed yet from the
     104                 :            :      conflicting graph during coloring.  */
     105                 :            :   unsigned int in_graph_p : 1;
     106                 :            :   /* TRUE if it is put on the stack to make other allocnos
     107                 :            :      colorable.  */
     108                 :            :   unsigned int may_be_spilled_p : 1;
     109                 :            :   /* TRUE if the allocno is trivially colorable.  */
     110                 :            :   unsigned int colorable_p : 1;
     111                 :            :   /* Number of hard registers of the allocno class really
     112                 :            :      available for the allocno allocation.  It is number of the
     113                 :            :      profitable hard regs.  */
     114                 :            :   int available_regs_num;
     115                 :            :   /* Sum of frequencies of hard register preferences of all
     116                 :            :      conflicting allocnos which are not the coloring stack yet.  */
     117                 :            :   int conflict_allocno_hard_prefs;
     118                 :            :   /* Allocnos in a bucket (used in coloring) chained by the following
     119                 :            :      two members.  */
     120                 :            :   ira_allocno_t next_bucket_allocno;
     121                 :            :   ira_allocno_t prev_bucket_allocno;
     122                 :            :   /* Used for temporary purposes.  */
     123                 :            :   int temp;
     124                 :            :   /* Used to exclude repeated processing.  */
     125                 :            :   int last_process;
     126                 :            :   /* Profitable hard regs available for this pseudo allocation.  It
     127                 :            :      means that the set excludes unavailable hard regs and hard regs
     128                 :            :      conflicting with given pseudo.  They should be of the allocno
     129                 :            :      class.  */
     130                 :            :   HARD_REG_SET profitable_hard_regs;
     131                 :            :   /* The allocno hard registers node.  */
     132                 :            :   allocno_hard_regs_node_t hard_regs_node;
     133                 :            :   /* Array of structures allocno_hard_regs_subnode representing
     134                 :            :      given allocno hard registers node (the 1st element in the array)
     135                 :            :      and all its subnodes in the tree (forest) of allocno hard
     136                 :            :      register nodes (see comments above).  */
     137                 :            :   int hard_regs_subnodes_start;
     138                 :            :   /* The length of the previous array.  */
     139                 :            :   int hard_regs_subnodes_num;
     140                 :            :   /* Records about updating allocno hard reg costs from copies.  If
     141                 :            :      the allocno did not get expected hard register, these records are
     142                 :            :      used to restore original hard reg costs of allocnos connected to
     143                 :            :      this allocno by copies.  */
     144                 :            :   struct update_cost_record *update_cost_records;
     145                 :            :   /* Threads.  We collect allocnos connected by copies into threads
     146                 :            :      and try to assign hard regs to allocnos by threads.  */
     147                 :            :   /* Allocno representing all thread.  */
     148                 :            :   ira_allocno_t first_thread_allocno;
     149                 :            :   /* Allocnos in thread forms a cycle list through the following
     150                 :            :      member.  */
     151                 :            :   ira_allocno_t next_thread_allocno;
     152                 :            :   /* All thread frequency.  Defined only for first thread allocno.  */
     153                 :            :   int thread_freq;
     154                 :            :   /* Sum of frequencies of hard register preferences of the allocno.  */
     155                 :            :   int hard_reg_prefs;
     156                 :            : };
     157                 :            : 
     158                 :            : /* See above.  */
     159                 :            : typedef struct allocno_color_data *allocno_color_data_t;
     160                 :            : 
     161                 :            : /* Container for storing allocno data concerning coloring.  */
     162                 :            : static allocno_color_data_t allocno_color_data;
     163                 :            : 
     164                 :            : /* Macro to access the data concerning coloring.  */
     165                 :            : #define ALLOCNO_COLOR_DATA(a) ((allocno_color_data_t) ALLOCNO_ADD_DATA (a))
     166                 :            : 
     167                 :            : /* Used for finding allocno colorability to exclude repeated allocno
     168                 :            :    processing and for updating preferencing to exclude repeated
     169                 :            :    allocno processing during assignment.  */
     170                 :            : static int curr_allocno_process;
     171                 :            : 
     172                 :            : /* This file contains code for regional graph coloring, spill/restore
     173                 :            :    code placement optimization, and code helping the reload pass to do
     174                 :            :    a better job.  */
     175                 :            : 
     176                 :            : /* Bitmap of allocnos which should be colored.  */
     177                 :            : static bitmap coloring_allocno_bitmap;
     178                 :            : 
     179                 :            : /* Bitmap of allocnos which should be taken into account during
     180                 :            :    coloring.  In general case it contains allocnos from
     181                 :            :    coloring_allocno_bitmap plus other already colored conflicting
     182                 :            :    allocnos.  */
     183                 :            : static bitmap consideration_allocno_bitmap;
     184                 :            : 
     185                 :            : /* All allocnos sorted according their priorities.  */
     186                 :            : static ira_allocno_t *sorted_allocnos;
     187                 :            : 
     188                 :            : /* Vec representing the stack of allocnos used during coloring.  */
     189                 :            : static vec<ira_allocno_t> allocno_stack_vec;
     190                 :            : 
     191                 :            : /* Helper for qsort comparison callbacks - return a positive integer if
     192                 :            :    X > Y, or a negative value otherwise.  Use a conditional expression
     193                 :            :    instead of a difference computation to insulate from possible overflow
     194                 :            :    issues, e.g. X - Y < 0 for some X > 0 and Y < 0.  */
     195                 :            : #define SORTGT(x,y) (((x) > (y)) ? 1 : -1)
     196                 :            : 
     197                 :            : 
     198                 :            : 
     199                 :            : /* Definition of vector of allocno hard registers.  */
     200                 :            : 
     201                 :            : /* Vector of unique allocno hard registers.  */
     202                 :            : static vec<allocno_hard_regs_t> allocno_hard_regs_vec;
     203                 :            : 
     204                 :            : struct allocno_hard_regs_hasher : nofree_ptr_hash <allocno_hard_regs>
     205                 :            : {
     206                 :            :   static inline hashval_t hash (const allocno_hard_regs *);
     207                 :            :   static inline bool equal (const allocno_hard_regs *,
     208                 :            :                             const allocno_hard_regs *);
     209                 :            : };
     210                 :            : 
     211                 :            : /* Returns hash value for allocno hard registers V.  */
     212                 :            : inline hashval_t
     213                 :  143309000 : allocno_hard_regs_hasher::hash (const allocno_hard_regs *hv)
     214                 :            : {
     215                 :  141388000 :   return iterative_hash (&hv->set, sizeof (HARD_REG_SET), 0);
     216                 :            : }
     217                 :            : 
     218                 :            : /* Compares allocno hard registers V1 and V2.  */
     219                 :            : inline bool
     220                 :   71034200 : allocno_hard_regs_hasher::equal (const allocno_hard_regs *hv1,
     221                 :            :                                  const allocno_hard_regs *hv2)
     222                 :            : {
     223                 :  142068000 :   return hv1->set == hv2->set;
     224                 :            : }
     225                 :            : 
     226                 :            : /* Hash table of unique allocno hard registers.  */
     227                 :            : static hash_table<allocno_hard_regs_hasher> *allocno_hard_regs_htab;
     228                 :            : 
     229                 :            : /* Return allocno hard registers in the hash table equal to HV.  */
     230                 :            : static allocno_hard_regs_t
     231                 :   55052300 : find_hard_regs (allocno_hard_regs_t hv)
     232                 :            : {
     233                 :          0 :   return allocno_hard_regs_htab->find (hv);
     234                 :            : }
     235                 :            : 
     236                 :            : /* Insert allocno hard registers HV in the hash table (if it is not
     237                 :            :    there yet) and return the value which in the table.  */
     238                 :            : static allocno_hard_regs_t
     239                 :   40227300 : insert_hard_regs (allocno_hard_regs_t hv)
     240                 :            : {
     241                 :   40227300 :   allocno_hard_regs **slot = allocno_hard_regs_htab->find_slot (hv, INSERT);
     242                 :            : 
     243                 :   40227300 :   if (*slot == NULL)
     244                 :   40227300 :     *slot = hv;
     245                 :   40227300 :   return *slot;
     246                 :            : }
     247                 :            : 
     248                 :            : /* Initialize data concerning allocno hard registers.  */
     249                 :            : static void
     250                 :     792963 : init_allocno_hard_regs (void)
     251                 :            : {
     252                 :     792963 :   allocno_hard_regs_vec.create (200);
     253                 :     792963 :   allocno_hard_regs_htab
     254                 :     792963 :     = new hash_table<allocno_hard_regs_hasher> (200);
     255                 :     792963 : }
     256                 :            : 
     257                 :            : /* Add (or update info about) allocno hard registers with SET and
     258                 :            :    COST.  */
     259                 :            : static allocno_hard_regs_t
     260                 :   55052300 : add_allocno_hard_regs (HARD_REG_SET set, int64_t cost)
     261                 :            : {
     262                 :   55052300 :   struct allocno_hard_regs temp;
     263                 :   55052300 :   allocno_hard_regs_t hv;
     264                 :            : 
     265                 :  110105000 :   gcc_assert (! hard_reg_set_empty_p (set));
     266                 :   55052300 :   temp.set = set;
     267                 :   55052300 :   if ((hv = find_hard_regs (&temp)) != NULL)
     268                 :   14825000 :     hv->cost += cost;
     269                 :            :   else
     270                 :            :     {
     271                 :   80454500 :       hv = ((struct allocno_hard_regs *)
     272                 :   40227300 :             ira_allocate (sizeof (struct allocno_hard_regs)));
     273                 :   40227300 :       hv->set = set;
     274                 :   40227300 :       hv->cost = cost;
     275                 :   40227300 :       allocno_hard_regs_vec.safe_push (hv);
     276                 :   40227300 :       insert_hard_regs (hv);
     277                 :            :     }
     278                 :   55052300 :   return hv;
     279                 :            : }
     280                 :            : 
     281                 :            : /* Finalize data concerning allocno hard registers.  */
     282                 :            : static void
     283                 :     792963 : finish_allocno_hard_regs (void)
     284                 :            : {
     285                 :     792963 :   int i;
     286                 :     792963 :   allocno_hard_regs_t hv;
     287                 :            : 
     288                 :   41020200 :   for (i = 0;
     289                 :   41020200 :        allocno_hard_regs_vec.iterate (i, &hv);
     290                 :            :        i++)
     291                 :   40227300 :     ira_free (hv);
     292                 :     792963 :   delete allocno_hard_regs_htab;
     293                 :     792963 :   allocno_hard_regs_htab = NULL;
     294                 :     792963 :   allocno_hard_regs_vec.release ();
     295                 :     792963 : }
     296                 :            : 
     297                 :            : /* Sort hard regs according to their frequency of usage. */
     298                 :            : static int
     299                 :   21861100 : allocno_hard_regs_compare (const void *v1p, const void *v2p)
     300                 :            : {
     301                 :   21861100 :   allocno_hard_regs_t hv1 = *(const allocno_hard_regs_t *) v1p;
     302                 :   21861100 :   allocno_hard_regs_t hv2 = *(const allocno_hard_regs_t *) v2p;
     303                 :            : 
     304                 :   21861100 :   if (hv2->cost > hv1->cost)
     305                 :            :     return 1;
     306                 :   11577500 :   else if (hv2->cost < hv1->cost)
     307                 :            :     return -1;
     308                 :     960433 :   return SORTGT (allocno_hard_regs_hasher::hash(hv2), allocno_hard_regs_hasher::hash(hv1));
     309                 :            : }
     310                 :            : 
     311                 :            : 
     312                 :            : 
     313                 :            : /* Used for finding a common ancestor of two allocno hard registers
     314                 :            :    nodes in the forest.  We use the current value of
     315                 :            :    'node_check_tick' to mark all nodes from one node to the top and
     316                 :            :    then walking up from another node until we find a marked node.
     317                 :            : 
     318                 :            :    It is also used to figure out allocno colorability as a mark that
     319                 :            :    we already reset value of member 'conflict_size' for the forest
     320                 :            :    node corresponding to the processed allocno.  */
     321                 :            : static int node_check_tick;
     322                 :            : 
     323                 :            : /* Roots of the forest containing hard register sets can be assigned
     324                 :            :    to allocnos.  */
     325                 :            : static allocno_hard_regs_node_t hard_regs_roots;
     326                 :            : 
     327                 :            : /* Definition of vector of allocno hard register nodes.  */
     328                 :            : 
     329                 :            : /* Vector used to create the forest.  */
     330                 :            : static vec<allocno_hard_regs_node_t> hard_regs_node_vec;
     331                 :            : 
     332                 :            : /* Create and return allocno hard registers node containing allocno
     333                 :            :    hard registers HV.  */
     334                 :            : static allocno_hard_regs_node_t
     335                 :   38776200 : create_new_allocno_hard_regs_node (allocno_hard_regs_t hv)
     336                 :            : {
     337                 :   38776200 :   allocno_hard_regs_node_t new_node;
     338                 :            : 
     339                 :   38776200 :   new_node = ((struct allocno_hard_regs_node *)
     340                 :   38776200 :               ira_allocate (sizeof (struct allocno_hard_regs_node)));
     341                 :   38776200 :   new_node->check = 0;
     342                 :   38776200 :   new_node->hard_regs = hv;
     343                 :   38776200 :   new_node->hard_regs_num = hard_reg_set_size (hv->set);
     344                 :   38776200 :   new_node->first = NULL;
     345                 :   38776200 :   new_node->used_p = false;
     346                 :   38776200 :   return new_node;
     347                 :            : }
     348                 :            : 
     349                 :            : /* Add allocno hard registers node NEW_NODE to the forest on its level
     350                 :            :    given by ROOTS.  */
     351                 :            : static void
     352                 :   38776200 : add_new_allocno_hard_regs_node_to_forest (allocno_hard_regs_node_t *roots,
     353                 :            :                                           allocno_hard_regs_node_t new_node)
     354                 :            : {
     355                 :   38776200 :   new_node->next = *roots;
     356                 :          0 :   if (new_node->next != NULL)
     357                 :   37190300 :     new_node->next->prev = new_node;
     358                 :   38776200 :   new_node->prev = NULL;
     359                 :   38776200 :   *roots = new_node;
     360                 :   38776200 : }
     361                 :            : 
     362                 :            : /* Add allocno hard registers HV (or its best approximation if it is
     363                 :            :    not possible) to the forest on its level given by ROOTS.  */
     364                 :            : static void
     365                 :    8859010 : add_allocno_hard_regs_to_forest (allocno_hard_regs_node_t *roots,
     366                 :            :                                  allocno_hard_regs_t hv)
     367                 :            : {
     368                 :    8859010 :   unsigned int i, start;
     369                 :    8859010 :   allocno_hard_regs_node_t node, prev, new_node;
     370                 :    8859010 :   HARD_REG_SET temp_set;
     371                 :    8859010 :   allocno_hard_regs_t hv2;
     372                 :            : 
     373                 :    8859010 :   start = hard_regs_node_vec.length ();
     374                 :   87303700 :   for (node = *roots; node != NULL; node = node->next)
     375                 :            :     {
     376                 :  167265000 :       if (hv->set == node->hard_regs->set)
     377                 :    5187670 :         return;
     378                 :  246138000 :       if (hard_reg_set_subset_p (hv->set, node->hard_regs->set))
     379                 :            :         {
     380                 :    3601250 :           add_allocno_hard_regs_to_forest (&node->first, hv);
     381                 :    3601250 :           return;
     382                 :            :         }
     383                 :  235334000 :       if (hard_reg_set_subset_p (node->hard_regs->set, hv->set))
     384                 :   46208500 :         hard_regs_node_vec.safe_push (node);
     385                 :   96708500 :       else if (hard_reg_set_intersect_p (hv->set, node->hard_regs->set))
     386                 :            :         {
     387                 :    3020910 :           temp_set = hv->set & node->hard_regs->set;
     388                 :    1006970 :           hv2 = add_allocno_hard_regs (temp_set, hv->cost);
     389                 :    1006970 :           add_allocno_hard_regs_to_forest (&node->first, hv2);
     390                 :            :         }
     391                 :            :     }
     392                 :    3671340 :   if (hard_regs_node_vec.length ()
     393                 :    3671340 :       > start + 1)
     394                 :            :     {
     395                 :            :       /* Create a new node which contains nodes in hard_regs_node_vec.  */
     396                 :    8399250 :       CLEAR_HARD_REG_SET (temp_set);
     397                 :   45390700 :       for (i = start;
     398                 :   48190400 :            i < hard_regs_node_vec.length ();
     399                 :            :            i++)
     400                 :            :         {
     401                 :   45390700 :           node = hard_regs_node_vec[i];
     402                 :   90781400 :           temp_set |= node->hard_regs->set;
     403                 :            :         }
     404                 :    2799750 :       hv = add_allocno_hard_regs (temp_set, hv->cost);
     405                 :    2799750 :       new_node = create_new_allocno_hard_regs_node (hv);
     406                 :    2799750 :       prev = NULL;
     407                 :    2799750 :       for (i = start;
     408                 :   96380900 :            i < hard_regs_node_vec.length ();
     409                 :            :            i++)
     410                 :            :         {
     411                 :   45390700 :           node = hard_regs_node_vec[i];
     412                 :   45390700 :           if (node->prev == NULL)
     413                 :   31910400 :             *roots = node->next;
     414                 :            :           else
     415                 :   13480300 :             node->prev->next = node->next;
     416                 :   45390700 :           if (node->next != NULL)
     417                 :   43264600 :             node->next->prev = node->prev;
     418                 :   45390700 :           if (prev == NULL)
     419                 :    2799750 :             new_node->first = node;
     420                 :            :           else
     421                 :   42590900 :             prev->next = node;
     422                 :   45390700 :           node->prev = prev;
     423                 :   45390700 :           node->next = NULL;
     424                 :   45390700 :           prev = node;
     425                 :            :         }
     426                 :    2799750 :       add_new_allocno_hard_regs_node_to_forest (roots, new_node);
     427                 :            :     }
     428                 :    3671340 :   hard_regs_node_vec.truncate (start);
     429                 :            : }
     430                 :            : 
     431                 :            : /* Add allocno hard registers nodes starting with the forest level
     432                 :            :    given by FIRST which contains biggest set inside SET.  */
     433                 :            : static void
     434                 :   41634500 : collect_allocno_hard_regs_cover (allocno_hard_regs_node_t first,
     435                 :            :                                  HARD_REG_SET set)
     436                 :            : {
     437                 :   41634500 :   allocno_hard_regs_node_t node;
     438                 :            : 
     439                 :   41634500 :   ira_assert (first != NULL);
     440                 :  457098000 :   for (node = first; node != NULL; node = node->next)
     441                 :  830926000 :     if (hard_reg_set_subset_p (node->hard_regs->set, set))
     442                 :   15770900 :       hard_regs_node_vec.safe_push (node);
     443                 : 1199080000 :     else if (hard_reg_set_intersect_p (set, node->hard_regs->set))
     444                 :   27158400 :       collect_allocno_hard_regs_cover (node->first, set);
     445                 :   41634500 : }
     446                 :            : 
     447                 :            : /* Set up field parent as PARENT in all allocno hard registers nodes
     448                 :            :    in forest given by FIRST.  */
     449                 :            : static void
     450                 :   39569200 : setup_allocno_hard_regs_nodes_parent (allocno_hard_regs_node_t first,
     451                 :            :                                       allocno_hard_regs_node_t parent)
     452                 :            : {
     453                 :   39569200 :   allocno_hard_regs_node_t node;
     454                 :            : 
     455                 :   78345400 :   for (node = first; node != NULL; node = node->next)
     456                 :            :     {
     457                 :   38776200 :       node->parent = parent;
     458                 :   38776200 :       setup_allocno_hard_regs_nodes_parent (node->first, node);
     459                 :            :     }
     460                 :   38776200 : }
     461                 :            : 
     462                 :            : /* Return allocno hard registers node which is a first common ancestor
     463                 :            :    node of FIRST and SECOND in the forest.  */
     464                 :            : static allocno_hard_regs_node_t
     465                 :          0 : first_common_ancestor_node (allocno_hard_regs_node_t first,
     466                 :            :                             allocno_hard_regs_node_t second)
     467                 :            : {
     468                 :    1294780 :   allocno_hard_regs_node_t node;
     469                 :            : 
     470                 :    1294780 :   node_check_tick++;
     471                 :    6628060 :   for (node = first; node != NULL; node = node->parent)
     472                 :    5333290 :     node->check = node_check_tick;
     473                 :    3376470 :   for (node = second; node != NULL; node = node->parent)
     474                 :    3376470 :     if (node->check == node_check_tick)
     475                 :          0 :       return node;
     476                 :            :   return first_common_ancestor_node (second, first);
     477                 :            : }
     478                 :            : 
     479                 :            : /* Print hard reg set SET to F.  */
     480                 :            : static void
     481                 :       1655 : print_hard_reg_set (FILE *f, HARD_REG_SET set, bool new_line_p)
     482                 :            : {
     483                 :       1655 :   int i, start, end;
     484                 :            : 
     485                 :     127435 :   for (start = end = -1, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     486                 :            :     {
     487                 :     125780 :       bool reg_included = TEST_HARD_REG_BIT (set, i);
     488                 :            : 
     489                 :     125780 :       if (reg_included)
     490                 :            :         {
     491                 :      48321 :           if (start == -1)
     492                 :       4007 :             start = i;
     493                 :            :           end = i;
     494                 :            :         }
     495                 :     125780 :       if (start >= 0 && (!reg_included || i == FIRST_PSEUDO_REGISTER - 1))
     496                 :            :         {
     497                 :       4007 :           if (start == end)
     498                 :        457 :             fprintf (f, " %d", start);
     499                 :       3550 :           else if (start == end + 1)
     500                 :          0 :             fprintf (f, " %d %d", start, end);
     501                 :            :           else
     502                 :       3550 :             fprintf (f, " %d-%d", start, end);
     503                 :            :           start = -1;
     504                 :            :         }
     505                 :            :     }
     506                 :       1655 :   if (new_line_p)
     507                 :          0 :     fprintf (f, "\n");
     508                 :       1655 : }
     509                 :            : 
     510                 :            : /* Print allocno hard register subforest given by ROOTS and its LEVEL
     511                 :            :    to F.  */
     512                 :            : static void
     513                 :        200 : print_hard_regs_subforest (FILE *f, allocno_hard_regs_node_t roots,
     514                 :            :                            int level)
     515                 :            : {
     516                 :        200 :   int i;
     517                 :        200 :   allocno_hard_regs_node_t node;
     518                 :            : 
     519                 :        361 :   for (node = roots; node != NULL; node = node->next)
     520                 :            :     {
     521                 :        161 :       fprintf (f, "    ");
     522                 :       1203 :       for (i = 0; i < level * 2; i++)
     523                 :       1042 :         fprintf (f, " ");
     524                 :        161 :       fprintf (f, "%d:(", node->preorder_num);
     525                 :        161 :       print_hard_reg_set (f, node->hard_regs->set, false);
     526                 :        161 :       fprintf (f, ")@%" PRId64"\n", node->hard_regs->cost);
     527                 :        161 :       print_hard_regs_subforest (f, node->first, level + 1);
     528                 :            :     }
     529                 :        200 : }
     530                 :            : 
     531                 :            : /* Print the allocno hard register forest to F.  */
     532                 :            : static void
     533                 :         39 : print_hard_regs_forest (FILE *f)
     534                 :            : {
     535                 :         39 :   fprintf (f, "    Hard reg set forest:\n");
     536                 :         39 :   print_hard_regs_subforest (f, hard_regs_roots, 1);
     537                 :         39 : }
     538                 :            : 
     539                 :            : /* Print the allocno hard register forest to stderr.  */
     540                 :            : void
     541                 :          0 : ira_debug_hard_regs_forest (void)
     542                 :            : {
     543                 :          0 :   print_hard_regs_forest (stderr);
     544                 :          0 : }
     545                 :            : 
     546                 :            : /* Remove unused allocno hard registers nodes from forest given by its
     547                 :            :    *ROOTS.  */
     548                 :            : static void
     549                 :    3343100 : remove_unused_allocno_hard_regs_nodes (allocno_hard_regs_node_t *roots)
     550                 :            : {
     551                 :    3343100 :   allocno_hard_regs_node_t node, prev, next, last;
     552                 :            : 
     553                 :   42119300 :   for (prev = NULL, node = *roots; node != NULL; node = next)
     554                 :            :     {
     555                 :   38776200 :       next = node->next;
     556                 :   38776200 :       if (node->used_p)
     557                 :            :         {
     558                 :    2550130 :           remove_unused_allocno_hard_regs_nodes (&node->first);
     559                 :    2550130 :           prev = node;
     560                 :            :         }
     561                 :            :       else
     562                 :            :         {
     563                 :   36226100 :           for (last = node->first;
     564                 :   37136000 :                last != NULL && last->next != NULL;
     565                 :            :                last = last->next)
     566                 :            :             ;
     567                 :   36226100 :           if (last != NULL)
     568                 :            :             {
     569                 :     254522 :               if (prev == NULL)
     570                 :     249655 :                 *roots = node->first;
     571                 :            :               else 
     572                 :       4867 :                 prev->next = node->first;
     573                 :     254522 :               if (next != NULL)
     574                 :     246606 :                 next->prev = last;
     575                 :     254522 :               last->next = next;
     576                 :     254522 :               next = node->first;
     577                 :            :             }
     578                 :            :           else
     579                 :            :             {
     580                 :   35971600 :               if (prev == NULL)
     581                 :   14701200 :                 *roots = next;
     582                 :            :               else
     583                 :   21270300 :                 prev->next = next;
     584                 :   35971600 :               if (next != NULL)
     585                 :   33507500 :                 next->prev = prev;
     586                 :            :             }
     587                 :   36226100 :           ira_free (node);
     588                 :            :         }
     589                 :            :     }
     590                 :    3343100 : }
     591                 :            : 
     592                 :            : /* Set up fields preorder_num starting with START_NUM in all allocno
     593                 :            :    hard registers nodes in forest given by FIRST.  Return biggest set
     594                 :            :    PREORDER_NUM increased by 1.  */
     595                 :            : static int
     596                 :    3343100 : enumerate_allocno_hard_regs_nodes (allocno_hard_regs_node_t first,
     597                 :            :                                    allocno_hard_regs_node_t parent,
     598                 :            :                                    int start_num)
     599                 :            : {
     600                 :    3343100 :   allocno_hard_regs_node_t node;
     601                 :            : 
     602                 :    5893230 :   for (node = first; node != NULL; node = node->next)
     603                 :            :     {
     604                 :    2550130 :       node->preorder_num = start_num++;
     605                 :    2550130 :       node->parent = parent;
     606                 :    2550130 :       start_num = enumerate_allocno_hard_regs_nodes (node->first, node,
     607                 :            :                                                      start_num);
     608                 :            :     }
     609                 :    3343100 :   return start_num;
     610                 :            : }
     611                 :            : 
     612                 :            : /* Number of allocno hard registers nodes in the forest.  */
     613                 :            : static int allocno_hard_regs_nodes_num;
     614                 :            : 
     615                 :            : /* Table preorder number of allocno hard registers node in the forest
     616                 :            :    -> the allocno hard registers node.  */
     617                 :            : static allocno_hard_regs_node_t *allocno_hard_regs_nodes;
     618                 :            : 
     619                 :            : /* See below.  */
     620                 :            : typedef struct allocno_hard_regs_subnode *allocno_hard_regs_subnode_t;
     621                 :            : 
     622                 :            : /* The structure is used to describes all subnodes (not only immediate
     623                 :            :    ones) in the mentioned above tree for given allocno hard register
     624                 :            :    node.  The usage of such data accelerates calculation of
     625                 :            :    colorability of given allocno.  */
     626                 :            : struct allocno_hard_regs_subnode
     627                 :            : {
     628                 :            :   /* The conflict size of conflicting allocnos whose hard register
     629                 :            :      sets are equal sets (plus supersets if given node is given
     630                 :            :      allocno hard registers node) of one in the given node.  */
     631                 :            :   int left_conflict_size;
     632                 :            :   /* The summary conflict size of conflicting allocnos whose hard
     633                 :            :      register sets are strict subsets of one in the given node.
     634                 :            :      Overall conflict size is
     635                 :            :      left_conflict_subnodes_size
     636                 :            :        + MIN (max_node_impact - left_conflict_subnodes_size,
     637                 :            :               left_conflict_size)
     638                 :            :   */
     639                 :            :   short left_conflict_subnodes_size;
     640                 :            :   short max_node_impact;
     641                 :            : };
     642                 :            : 
     643                 :            : /* Container for hard regs subnodes of all allocnos.  */
     644                 :            : static allocno_hard_regs_subnode_t allocno_hard_regs_subnodes;
     645                 :            : 
     646                 :            : /* Table (preorder number of allocno hard registers node in the
     647                 :            :    forest, preorder number of allocno hard registers subnode) -> index
     648                 :            :    of the subnode relative to the node.  -1 if it is not a
     649                 :            :    subnode.  */
     650                 :            : static int *allocno_hard_regs_subnode_index;
     651                 :            : 
     652                 :            : /* Setup arrays ALLOCNO_HARD_REGS_NODES and
     653                 :            :    ALLOCNO_HARD_REGS_SUBNODE_INDEX.  */
     654                 :            : static void
     655                 :    3343100 : setup_allocno_hard_regs_subnode_index (allocno_hard_regs_node_t first)
     656                 :            : {
     657                 :    3343100 :   allocno_hard_regs_node_t node, parent;
     658                 :    3343100 :   int index;
     659                 :            : 
     660                 :    5893230 :   for (node = first; node != NULL; node = node->next)
     661                 :            :     {
     662                 :    2550130 :       allocno_hard_regs_nodes[node->preorder_num] = node;
     663                 :    8740810 :       for (parent = node; parent != NULL; parent = parent->parent)
     664                 :            :         {
     665                 :    6190680 :           index = parent->preorder_num * allocno_hard_regs_nodes_num;
     666                 :    6190680 :           allocno_hard_regs_subnode_index[index + node->preorder_num]
     667                 :    6190680 :             = node->preorder_num - parent->preorder_num;
     668                 :            :         }
     669                 :    2550130 :       setup_allocno_hard_regs_subnode_index (node->first);
     670                 :            :     }
     671                 :    3343100 : }
     672                 :            : 
     673                 :            : /* Count all allocno hard registers nodes in tree ROOT.  */
     674                 :            : static int
     675                 :   39597100 : get_allocno_hard_regs_subnodes_num (allocno_hard_regs_node_t root)
     676                 :            : {
     677                 :   39597100 :   int len = 1;
     678                 :            : 
     679                 :   64718000 :   for (root = root->first; root != NULL; root = root->next)
     680                 :   25120900 :     len += get_allocno_hard_regs_subnodes_num (root);
     681                 :   39597100 :   return len;
     682                 :            : }
     683                 :            : 
     684                 :            : /* Build the forest of allocno hard registers nodes and assign each
     685                 :            :    allocno a node from the forest.  */
     686                 :            : static void
     687                 :     792963 : form_allocno_hard_regs_nodes_forest (void)
     688                 :            : {
     689                 :     792963 :   unsigned int i, j, size, len;
     690                 :     792963 :   int start;
     691                 :     792963 :   ira_allocno_t a;
     692                 :     792963 :   allocno_hard_regs_t hv;
     693                 :     792963 :   bitmap_iterator bi;
     694                 :     792963 :   HARD_REG_SET temp;
     695                 :     792963 :   allocno_hard_regs_node_t node, allocno_hard_regs_node;
     696                 :     792963 :   allocno_color_data_t allocno_data;
     697                 :            : 
     698                 :     792963 :   node_check_tick = 0;
     699                 :     792963 :   init_allocno_hard_regs ();
     700                 :     792963 :   hard_regs_roots = NULL;
     701                 :     792963 :   hard_regs_node_vec.create (100);
     702                 :   61058200 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     703                 :   60265200 :     if (! TEST_HARD_REG_BIT (ira_no_alloc_regs, i))
     704                 :            :       {
     705                 :  107929000 :         CLEAR_HARD_REG_SET (temp);
     706                 :   35976500 :         SET_HARD_REG_BIT (temp, i);
     707                 :   35976500 :         hv = add_allocno_hard_regs (temp, 0);
     708                 :   35976500 :         node = create_new_allocno_hard_regs_node (hv);
     709                 :   96241700 :         add_new_allocno_hard_regs_node_to_forest (&hard_regs_roots, node);
     710                 :            :       }
     711                 :     792963 :   start = allocno_hard_regs_vec.length ();
     712                 :   17119900 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
     713                 :            :     {
     714                 :   16327000 :       a = ira_allocnos[i];
     715                 :   16327000 :       allocno_data = ALLOCNO_COLOR_DATA (a);
     716                 :            :       
     717                 :   32653900 :       if (hard_reg_set_empty_p (allocno_data->profitable_hard_regs))
     718                 :    1850830 :         continue;
     719                 :   14476100 :       hv = (add_allocno_hard_regs
     720                 :   14476100 :             (allocno_data->profitable_hard_regs,
     721                 :   14476100 :              ALLOCNO_MEMORY_COST (a) - ALLOCNO_CLASS_COST (a)));
     722                 :            :     }
     723                 :     792963 :   temp = ~ira_no_alloc_regs;
     724                 :     792963 :   add_allocno_hard_regs (temp, 0);
     725                 :    2378890 :   qsort (allocno_hard_regs_vec.address () + start,
     726                 :            :          allocno_hard_regs_vec.length () - start,
     727                 :            :          sizeof (allocno_hard_regs_t), allocno_hard_regs_compare);
     728                 :    5043750 :   for (i = start;
     729                 :    5043750 :        allocno_hard_regs_vec.iterate (i, &hv);
     730                 :            :        i++)
     731                 :            :     {
     732                 :    4250790 :       add_allocno_hard_regs_to_forest (&hard_regs_roots, hv);
     733                 :    4250790 :       ira_assert (hard_regs_node_vec.length () == 0);
     734                 :            :     }
     735                 :            :   /* We need to set up parent fields for right work of
     736                 :            :      first_common_ancestor_node. */
     737                 :     792963 :   setup_allocno_hard_regs_nodes_parent (hard_regs_roots, NULL);
     738                 :   17119900 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
     739                 :            :     {
     740                 :   16327000 :       a = ira_allocnos[i];
     741                 :   16327000 :       allocno_data = ALLOCNO_COLOR_DATA (a);
     742                 :   32653900 :       if (hard_reg_set_empty_p (allocno_data->profitable_hard_regs))
     743                 :    1850830 :         continue;
     744                 :   14476100 :       hard_regs_node_vec.truncate (0);
     745                 :   14476100 :       collect_allocno_hard_regs_cover (hard_regs_roots,
     746                 :            :                                        allocno_data->profitable_hard_regs);
     747                 :   14476100 :       allocno_hard_regs_node = NULL;
     748                 :   30247100 :       for (j = 0; hard_regs_node_vec.iterate (j, &node); j++)
     749                 :   15770900 :         allocno_hard_regs_node
     750                 :   15770900 :           = (j == 0
     751                 :   15770900 :              ? node
     752                 :   17065700 :              : first_common_ancestor_node (node, allocno_hard_regs_node));
     753                 :            :       /* That is a temporary storage.  */
     754                 :   14476100 :       allocno_hard_regs_node->used_p = true;
     755                 :   14476100 :       allocno_data->hard_regs_node = allocno_hard_regs_node;
     756                 :            :     }
     757                 :     792963 :   ira_assert (hard_regs_roots->next == NULL);
     758                 :     792963 :   hard_regs_roots->used_p = true;
     759                 :     792963 :   remove_unused_allocno_hard_regs_nodes (&hard_regs_roots);
     760                 :     792963 :   allocno_hard_regs_nodes_num
     761                 :     792963 :     = enumerate_allocno_hard_regs_nodes (hard_regs_roots, NULL, 0);
     762                 :     792963 :   allocno_hard_regs_nodes
     763                 :     792963 :     = ((allocno_hard_regs_node_t *)
     764                 :     792963 :        ira_allocate (allocno_hard_regs_nodes_num
     765                 :            :                      * sizeof (allocno_hard_regs_node_t)));
     766                 :     792963 :   size = allocno_hard_regs_nodes_num * allocno_hard_regs_nodes_num;
     767                 :     792963 :   allocno_hard_regs_subnode_index
     768                 :     792963 :     = (int *) ira_allocate (size * sizeof (int));
     769                 :   11254400 :   for (i = 0; i < size; i++)
     770                 :   10461500 :     allocno_hard_regs_subnode_index[i] = -1;
     771                 :     792963 :   setup_allocno_hard_regs_subnode_index (hard_regs_roots);
     772                 :     792963 :   start = 0;
     773                 :   17119900 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
     774                 :            :     {
     775                 :   16327000 :       a = ira_allocnos[i];
     776                 :   16327000 :       allocno_data = ALLOCNO_COLOR_DATA (a);
     777                 :   32653900 :       if (hard_reg_set_empty_p (allocno_data->profitable_hard_regs))
     778                 :    1850830 :         continue;
     779                 :   14476100 :       len = get_allocno_hard_regs_subnodes_num (allocno_data->hard_regs_node);
     780                 :   14476100 :       allocno_data->hard_regs_subnodes_start = start;
     781                 :   14476100 :       allocno_data->hard_regs_subnodes_num = len;
     782                 :   14476100 :       start += len;
     783                 :            :     }
     784                 :     792963 :   allocno_hard_regs_subnodes
     785                 :     792963 :     = ((allocno_hard_regs_subnode_t)
     786                 :     792963 :        ira_allocate (sizeof (struct allocno_hard_regs_subnode) * start));
     787                 :     792963 :   hard_regs_node_vec.release ();
     788                 :     792963 : }
     789                 :            : 
     790                 :            : /* Free tree of allocno hard registers nodes given by its ROOT.  */
     791                 :            : static void
     792                 :    2550130 : finish_allocno_hard_regs_nodes_tree (allocno_hard_regs_node_t root)
     793                 :            : {
     794                 :    2550130 :   allocno_hard_regs_node_t child, next;
     795                 :            : 
     796                 :    4307300 :   for (child = root->first; child != NULL; child = next)
     797                 :            :     {
     798                 :    1757170 :       next = child->next;
     799                 :    1757170 :       finish_allocno_hard_regs_nodes_tree (child);
     800                 :            :     }
     801                 :    2550130 :   ira_free (root);
     802                 :    2550130 : }
     803                 :            : 
     804                 :            : /* Finish work with the forest of allocno hard registers nodes.  */
     805                 :            : static void
     806                 :     792963 : finish_allocno_hard_regs_nodes_forest (void)
     807                 :            : {
     808                 :     792963 :   allocno_hard_regs_node_t node, next;
     809                 :            :   
     810                 :     792963 :   ira_free (allocno_hard_regs_subnodes);
     811                 :    1585930 :   for (node = hard_regs_roots; node != NULL; node = next)
     812                 :            :     {
     813                 :     792963 :       next = node->next;
     814                 :     792963 :       finish_allocno_hard_regs_nodes_tree (node);
     815                 :            :     }
     816                 :     792963 :   ira_free (allocno_hard_regs_nodes);
     817                 :     792963 :   ira_free (allocno_hard_regs_subnode_index);
     818                 :     792963 :   finish_allocno_hard_regs ();
     819                 :     792963 : }
     820                 :            : 
     821                 :            : /* Set up left conflict sizes and left conflict subnodes sizes of hard
     822                 :            :    registers subnodes of allocno A.  Return TRUE if allocno A is
     823                 :            :    trivially colorable.  */
     824                 :            : static bool
     825                 :   14476100 : setup_left_conflict_sizes_p (ira_allocno_t a)
     826                 :            : {
     827                 :   14476100 :   int i, k, nobj, start;
     828                 :   14476100 :   int conflict_size, left_conflict_subnodes_size, node_preorder_num;
     829                 :   14476100 :   allocno_color_data_t data;
     830                 :   14476100 :   HARD_REG_SET profitable_hard_regs;
     831                 :   14476100 :   allocno_hard_regs_subnode_t subnodes;
     832                 :   14476100 :   allocno_hard_regs_node_t node;
     833                 :   14476100 :   HARD_REG_SET node_set;
     834                 :            : 
     835                 :   14476100 :   nobj = ALLOCNO_NUM_OBJECTS (a);
     836                 :   14476100 :   data = ALLOCNO_COLOR_DATA (a);
     837                 :   14476100 :   subnodes = allocno_hard_regs_subnodes + data->hard_regs_subnodes_start;
     838                 :   14476100 :   profitable_hard_regs = data->profitable_hard_regs;
     839                 :   14476100 :   node = data->hard_regs_node;
     840                 :   14476100 :   node_preorder_num = node->preorder_num;
     841                 :   14476100 :   node_set = node->hard_regs->set;
     842                 :   14476100 :   node_check_tick++;
     843                 :   29212000 :   for (k = 0; k < nobj; k++)
     844                 :            :     {
     845                 :   14735900 :       ira_object_t obj = ALLOCNO_OBJECT (a, k);
     846                 :   14735900 :       ira_object_t conflict_obj;
     847                 :   14735900 :       ira_object_conflict_iterator oci;
     848                 :            :       
     849                 :  398606000 :       FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
     850                 :            :         {
     851                 :  383870000 :           int size;
     852                 :  383870000 :           ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
     853                 :  383870000 :           allocno_hard_regs_node_t conflict_node, temp_node;
     854                 :  383870000 :           HARD_REG_SET conflict_node_set;
     855                 :  383870000 :           allocno_color_data_t conflict_data;
     856                 :            : 
     857                 :  383870000 :           conflict_data = ALLOCNO_COLOR_DATA (conflict_a);
     858                 :  437874000 :           if (! ALLOCNO_COLOR_DATA (conflict_a)->in_graph_p
     859                 :  714795000 :               || ! hard_reg_set_intersect_p (profitable_hard_regs,
     860                 :            :                                              conflict_data
     861                 :  992774000 :                                              ->profitable_hard_regs))
     862                 :   54004300 :             continue;
     863                 :  329866000 :           conflict_node = conflict_data->hard_regs_node;
     864                 :  329866000 :           conflict_node_set = conflict_node->hard_regs->set;
     865                 :  659732000 :           if (hard_reg_set_subset_p (node_set, conflict_node_set))
     866                 :            :             temp_node = node;
     867                 :            :           else
     868                 :            :             {
     869                 :  238026000 :               ira_assert (hard_reg_set_subset_p (conflict_node_set, node_set));
     870                 :            :               temp_node = conflict_node;
     871                 :            :             }
     872                 :  329866000 :           if (temp_node->check != node_check_tick)
     873                 :            :             {
     874                 :   23462000 :               temp_node->check = node_check_tick;
     875                 :   23462000 :               temp_node->conflict_size = 0;
     876                 :            :             }
     877                 :  329866000 :           size = (ira_reg_class_max_nregs
     878                 :  329866000 :                   [ALLOCNO_CLASS (conflict_a)][ALLOCNO_MODE (conflict_a)]);
     879                 :  329866000 :           if (ALLOCNO_NUM_OBJECTS (conflict_a) > 1)
     880                 :            :             /* We will deal with the subwords individually.  */
     881                 :   17479200 :             size = 1;
     882                 :  329866000 :           temp_node->conflict_size += size;
     883                 :            :         }
     884                 :            :     }
     885                 :   54073200 :   for (i = 0; i < data->hard_regs_subnodes_num; i++)
     886                 :            :     {
     887                 :   39597100 :       allocno_hard_regs_node_t temp_node;
     888                 :            :       
     889                 :   39597100 :       temp_node = allocno_hard_regs_nodes[i + node_preorder_num];
     890                 :   39597100 :       ira_assert (temp_node->preorder_num == i + node_preorder_num);
     891                 :   79194200 :       subnodes[i].left_conflict_size = (temp_node->check != node_check_tick
     892                 :   39597100 :                                         ? 0 : temp_node->conflict_size);
     893                 :   79194200 :       if (hard_reg_set_subset_p (temp_node->hard_regs->set,
     894                 :            :                                  profitable_hard_regs))
     895                 :   37443800 :         subnodes[i].max_node_impact = temp_node->hard_regs_num;
     896                 :            :       else
     897                 :            :         {
     898                 :            :           HARD_REG_SET temp_set;
     899                 :            :           int j, n, hard_regno;
     900                 :            :           enum reg_class aclass;
     901                 :            :           
     902                 :    6459860 :           temp_set = temp_node->hard_regs->set & profitable_hard_regs;
     903                 :    2153290 :           aclass = ALLOCNO_CLASS (a);
     904                 :   35722200 :           for (n = 0, j = ira_class_hard_regs_num[aclass] - 1; j >= 0; j--)
     905                 :            :             {
     906                 :   33568900 :               hard_regno = ira_class_hard_regs[aclass][j];
     907                 :   33568900 :               if (TEST_HARD_REG_BIT (temp_set, hard_regno))
     908                 :   24603600 :                 n++;
     909                 :            :             }
     910                 :    2153290 :           subnodes[i].max_node_impact = n;
     911                 :            :         }
     912                 :   39597100 :       subnodes[i].left_conflict_subnodes_size = 0;
     913                 :            :     }
     914                 :   14476100 :   start = node_preorder_num * allocno_hard_regs_nodes_num;
     915                 :   39597100 :   for (i = data->hard_regs_subnodes_num - 1; i > 0; i--)
     916                 :            :     {
     917                 :   25120900 :       int size, parent_i;
     918                 :   25120900 :       allocno_hard_regs_node_t parent;
     919                 :            :       
     920                 :   25120900 :       size = (subnodes[i].left_conflict_subnodes_size
     921                 :   25120900 :               + MIN (subnodes[i].max_node_impact
     922                 :            :                      - subnodes[i].left_conflict_subnodes_size,
     923                 :            :                      subnodes[i].left_conflict_size));
     924                 :   25120900 :       parent = allocno_hard_regs_nodes[i + node_preorder_num]->parent;
     925                 :   25120900 :       gcc_checking_assert(parent);
     926                 :   25120900 :       parent_i
     927                 :   25120900 :         = allocno_hard_regs_subnode_index[start + parent->preorder_num];
     928                 :   25120900 :       gcc_checking_assert(parent_i >= 0);
     929                 :   25120900 :       subnodes[parent_i].left_conflict_subnodes_size += size;
     930                 :            :     }
     931                 :   14476100 :   left_conflict_subnodes_size = subnodes[0].left_conflict_subnodes_size;
     932                 :   14476100 :   conflict_size
     933                 :   14476100 :     = (left_conflict_subnodes_size
     934                 :   14476100 :        + MIN (subnodes[0].max_node_impact - left_conflict_subnodes_size,
     935                 :            :               subnodes[0].left_conflict_size));
     936                 :   14476100 :   conflict_size += ira_reg_class_max_nregs[ALLOCNO_CLASS (a)][ALLOCNO_MODE (a)];
     937                 :   14476100 :   data->colorable_p = conflict_size <= data->available_regs_num;
     938                 :   14476100 :   return data->colorable_p;
     939                 :            : }
     940                 :            : 
     941                 :            : /* Update left conflict sizes of hard registers subnodes of allocno A
     942                 :            :    after removing allocno REMOVED_A with SIZE from the conflict graph.
     943                 :            :    Return TRUE if A is trivially colorable.  */
     944                 :            : static bool
     945                 :  147796000 : update_left_conflict_sizes_p (ira_allocno_t a,
     946                 :            :                               ira_allocno_t removed_a, int size)
     947                 :            : {
     948                 :  147796000 :   int i, conflict_size, before_conflict_size, diff, start;
     949                 :  147796000 :   int node_preorder_num, parent_i;
     950                 :  147796000 :   allocno_hard_regs_node_t node, removed_node, parent;
     951                 :  147796000 :   allocno_hard_regs_subnode_t subnodes;
     952                 :  147796000 :   allocno_color_data_t data = ALLOCNO_COLOR_DATA (a);
     953                 :            : 
     954                 :  147796000 :   ira_assert (! data->colorable_p);
     955                 :  147796000 :   node = data->hard_regs_node;
     956                 :  147796000 :   node_preorder_num = node->preorder_num;
     957                 :  147796000 :   removed_node = ALLOCNO_COLOR_DATA (removed_a)->hard_regs_node;
     958                 :  409296000 :   ira_assert (hard_reg_set_subset_p (removed_node->hard_regs->set,
     959                 :            :                                node->hard_regs->set)
     960                 :            :               || hard_reg_set_subset_p (node->hard_regs->set,
     961                 :            :                                         removed_node->hard_regs->set));
     962                 :  147796000 :   start = node_preorder_num * allocno_hard_regs_nodes_num;
     963                 :  147796000 :   i = allocno_hard_regs_subnode_index[start + removed_node->preorder_num];
     964                 :  147796000 :   if (i < 0)
     965                 :            :     i = 0;
     966                 :  147796000 :   subnodes = allocno_hard_regs_subnodes + data->hard_regs_subnodes_start;
     967                 :  147796000 :   before_conflict_size
     968                 :  147796000 :     = (subnodes[i].left_conflict_subnodes_size
     969                 :  147796000 :        + MIN (subnodes[i].max_node_impact
     970                 :            :               - subnodes[i].left_conflict_subnodes_size,
     971                 :            :               subnodes[i].left_conflict_size));
     972                 :  147796000 :   subnodes[i].left_conflict_size -= size;
     973                 :  162268000 :   for (;;)
     974                 :            :     {
     975                 :  155032000 :       conflict_size
     976                 :  155032000 :         = (subnodes[i].left_conflict_subnodes_size
     977                 :  155032000 :            + MIN (subnodes[i].max_node_impact
     978                 :            :                   - subnodes[i].left_conflict_subnodes_size,
     979                 :            :                   subnodes[i].left_conflict_size));
     980                 :  155032000 :       if ((diff = before_conflict_size - conflict_size) == 0)
     981                 :            :         break;
     982                 :   10522500 :       ira_assert (conflict_size < before_conflict_size);
     983                 :   10522500 :       parent = allocno_hard_regs_nodes[i + node_preorder_num]->parent;
     984                 :   10522500 :       if (parent == NULL)
     985                 :            :         break;
     986                 :   10522200 :       parent_i
     987                 :   10522200 :         = allocno_hard_regs_subnode_index[start + parent->preorder_num];
     988                 :   10522200 :       if (parent_i < 0)
     989                 :            :         break;
     990                 :    7235800 :       i = parent_i;
     991                 :    7235800 :       before_conflict_size
     992                 :    7235800 :         = (subnodes[i].left_conflict_subnodes_size
     993                 :    7235800 :            + MIN (subnodes[i].max_node_impact
     994                 :            :                   - subnodes[i].left_conflict_subnodes_size,
     995                 :            :                   subnodes[i].left_conflict_size));
     996                 :    7235800 :       subnodes[i].left_conflict_subnodes_size -= diff;
     997                 :            :     }
     998                 :  147796000 :   if (i != 0
     999                 :  134136000 :       || (conflict_size 
    1000                 :  134136000 :           + ira_reg_class_max_nregs[ALLOCNO_CLASS (a)][ALLOCNO_MODE (a)]
    1001                 :  134136000 :           > data->available_regs_num))
    1002                 :            :     return false;
    1003                 :    3225540 :   data->colorable_p = true;
    1004                 :    3225540 :   return true;
    1005                 :            : }
    1006                 :            : 
    1007                 :            : /* Return true if allocno A has empty profitable hard regs.  */
    1008                 :            : static bool
    1009                 :   47438300 : empty_profitable_hard_regs (ira_allocno_t a)
    1010                 :            : {
    1011                 :   47438300 :   allocno_color_data_t data = ALLOCNO_COLOR_DATA (a);
    1012                 :            : 
    1013                 :   31111800 :   return hard_reg_set_empty_p (data->profitable_hard_regs);
    1014                 :            : }
    1015                 :            : 
    1016                 :            : /* Set up profitable hard registers for each allocno being
    1017                 :            :    colored.  */
    1018                 :            : static void
    1019                 :     792991 : setup_profitable_hard_regs (void)
    1020                 :            : {
    1021                 :     792991 :   unsigned int i;
    1022                 :     792991 :   int j, k, nobj, hard_regno, nregs, class_size;
    1023                 :     792991 :   ira_allocno_t a;
    1024                 :     792991 :   bitmap_iterator bi;
    1025                 :     792991 :   enum reg_class aclass;
    1026                 :     792991 :   machine_mode mode;
    1027                 :     792991 :   allocno_color_data_t data;
    1028                 :            : 
    1029                 :            :   /* Initial set up from allocno classes and explicitly conflicting
    1030                 :            :      hard regs.  */
    1031                 :   17121200 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    1032                 :            :     {
    1033                 :   16328200 :       a = ira_allocnos[i];
    1034                 :   16328200 :       if ((aclass = ALLOCNO_CLASS (a)) == NO_REGS)
    1035                 :     771726 :         continue;
    1036                 :   15556500 :       data = ALLOCNO_COLOR_DATA (a);
    1037                 :   15556500 :       if (ALLOCNO_UPDATED_HARD_REG_COSTS (a) == NULL
    1038                 :   14936500 :           && ALLOCNO_CLASS_COST (a) > ALLOCNO_MEMORY_COST (a)
    1039                 :            :           /* Do not empty profitable regs for static chain pointer
    1040                 :            :              pseudo when non-local goto is used.  */
    1041                 :   15607700 :           && ! non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a)))
    1042                 :   16430600 :         CLEAR_HARD_REG_SET (data->profitable_hard_regs);
    1043                 :            :       else
    1044                 :            :         {
    1045                 :   15505300 :           mode = ALLOCNO_MODE (a);
    1046                 :   15505300 :           data->profitable_hard_regs
    1047                 :   15505300 :             = ira_useful_class_mode_regs[aclass][mode];
    1048                 :   15505300 :           nobj = ALLOCNO_NUM_OBJECTS (a);
    1049                 :   31292900 :           for (k = 0; k < nobj; k++)
    1050                 :            :             {
    1051                 :   15787600 :               ira_object_t obj = ALLOCNO_OBJECT (a, k);
    1052                 :            :               
    1053                 :   15787600 :               data->profitable_hard_regs
    1054                 :   47362700 :                 &= ~OBJECT_TOTAL_CONFLICT_HARD_REGS (obj);
    1055                 :            :             }
    1056                 :            :         }
    1057                 :            :     }
    1058                 :            :   /* Exclude hard regs already assigned for conflicting objects.  */
    1059                 :   17747400 :   EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, i, bi)
    1060                 :            :     {
    1061                 :   16954400 :       a = ira_allocnos[i];
    1062                 :   33619900 :       if ((aclass = ALLOCNO_CLASS (a)) == NO_REGS
    1063                 :   15956600 :           || ! ALLOCNO_ASSIGNED_P (a)
    1064                 :   17354500 :           || (hard_regno = ALLOCNO_HARD_REGNO (a)) < 0)
    1065                 :   16665500 :         continue;
    1066                 :     288854 :       mode = ALLOCNO_MODE (a);
    1067                 :     288854 :       nregs = hard_regno_nregs (hard_regno, mode);
    1068                 :     288854 :       nobj = ALLOCNO_NUM_OBJECTS (a);
    1069                 :     581910 :       for (k = 0; k < nobj; k++)
    1070                 :            :         {
    1071                 :     293056 :           ira_object_t obj = ALLOCNO_OBJECT (a, k);
    1072                 :     293056 :           ira_object_t conflict_obj;
    1073                 :     293056 :           ira_object_conflict_iterator oci;
    1074                 :            : 
    1075                 :    4208480 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    1076                 :            :             {
    1077                 :    3622370 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    1078                 :            : 
    1079                 :            :               /* We can process the conflict allocno repeatedly with
    1080                 :            :                  the same result.  */
    1081                 :    3622370 :               if (nregs == nobj && nregs > 1)
    1082                 :            :                 {
    1083                 :     180001 :                   int num = OBJECT_SUBWORD (conflict_obj);
    1084                 :            :                   
    1085                 :     180001 :                   if (REG_WORDS_BIG_ENDIAN)
    1086                 :            :                     CLEAR_HARD_REG_BIT
    1087                 :            :                       (ALLOCNO_COLOR_DATA (conflict_a)->profitable_hard_regs,
    1088                 :            :                        hard_regno + nobj - num - 1);
    1089                 :            :                   else
    1090                 :     180001 :                     CLEAR_HARD_REG_BIT
    1091                 :    3915430 :                       (ALLOCNO_COLOR_DATA (conflict_a)->profitable_hard_regs,
    1092                 :     180001 :                        hard_regno + num);
    1093                 :            :                 }
    1094                 :            :               else
    1095                 :    6884740 :                 ALLOCNO_COLOR_DATA (conflict_a)->profitable_hard_regs
    1096                 :   10327100 :                   &= ~ira_reg_mode_hard_regset[hard_regno][mode];
    1097                 :            :             }
    1098                 :            :         }
    1099                 :            :     }
    1100                 :            :   /* Exclude too costly hard regs.  */
    1101                 :   17121200 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    1102                 :            :     {
    1103                 :   16328200 :       int min_cost = INT_MAX;
    1104                 :   16328200 :       int *costs;
    1105                 :            : 
    1106                 :   16328200 :       a = ira_allocnos[i];
    1107                 :   17157700 :       if ((aclass = ALLOCNO_CLASS (a)) == NO_REGS
    1108                 :   31884700 :           || empty_profitable_hard_regs (a))
    1109                 :     829502 :         continue;
    1110                 :   15498700 :       data = ALLOCNO_COLOR_DATA (a);
    1111                 :   15498700 :       if ((costs = ALLOCNO_UPDATED_HARD_REG_COSTS (a)) != NULL
    1112                 :   15498700 :           || (costs = ALLOCNO_HARD_REG_COSTS (a)) != NULL)
    1113                 :            :         {
    1114                 :    7001150 :           class_size = ira_class_hard_regs_num[aclass];
    1115                 :  110959000 :           for (j = 0; j < class_size; j++)
    1116                 :            :             {
    1117                 :  103958000 :               hard_regno = ira_class_hard_regs[aclass][j];
    1118                 :  103958000 :               if (! TEST_HARD_REG_BIT (data->profitable_hard_regs,
    1119                 :            :                                        hard_regno))
    1120                 :   11577700 :                 continue;
    1121                 :   92380600 :               if (ALLOCNO_UPDATED_MEMORY_COST (a) < costs[j]
    1122                 :            :                   /* Do not remove HARD_REGNO for static chain pointer
    1123                 :            :                      pseudo when non-local goto is used.  */
    1124                 :   92380600 :                   && ! non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a)))
    1125                 :  103958000 :                 CLEAR_HARD_REG_BIT (data->profitable_hard_regs,
    1126                 :            :                                     hard_regno);
    1127                 :   87056500 :               else if (min_cost > costs[j])
    1128                 :            :                 min_cost = costs[j];
    1129                 :            :             }
    1130                 :            :         }
    1131                 :    8497550 :       else if (ALLOCNO_UPDATED_MEMORY_COST (a)
    1132                 :    8497550 :                < ALLOCNO_UPDATED_CLASS_COST (a)
    1133                 :            :                /* Do not empty profitable regs for static chain
    1134                 :            :                   pointer pseudo when non-local goto is used.  */
    1135                 :    8497550 :                && ! non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a)))
    1136                 :    2293530 :         CLEAR_HARD_REG_SET (data->profitable_hard_regs);
    1137                 :   15498700 :       if (ALLOCNO_UPDATED_CLASS_COST (a) > min_cost)
    1138                 :      17719 :         ALLOCNO_UPDATED_CLASS_COST (a) = min_cost;
    1139                 :            :     }
    1140                 :     792991 : }
    1141                 :            : 
    1142                 :            : 
    1143                 :            : 
    1144                 :            : /* This page contains functions used to choose hard registers for
    1145                 :            :    allocnos.  */
    1146                 :            : 
    1147                 :            : /* Pool for update cost records.  */
    1148                 :            : static object_allocator<update_cost_record> update_cost_record_pool
    1149                 :            :   ("update cost records");
    1150                 :            : 
    1151                 :            : /* Return new update cost record with given params.  */
    1152                 :            : static struct update_cost_record *
    1153                 :    8609780 : get_update_cost_record (int hard_regno, int divisor,
    1154                 :            :                         struct update_cost_record *next)
    1155                 :            : {
    1156                 :    8609780 :   struct update_cost_record *record;
    1157                 :            : 
    1158                 :          0 :   record = update_cost_record_pool.allocate ();
    1159                 :    8609780 :   record->hard_regno = hard_regno;
    1160                 :    8609780 :   record->divisor = divisor;
    1161                 :    8609780 :   record->next = next;
    1162                 :    8609780 :   return record;
    1163                 :            : }
    1164                 :            : 
    1165                 :            : /* Free memory for all records in LIST.  */
    1166                 :            : static void
    1167                 :          0 : free_update_cost_record_list (struct update_cost_record *list)
    1168                 :            : {
    1169                 :   23279100 :   struct update_cost_record *next;
    1170                 :            : 
    1171                 :   23279100 :   while (list != NULL)
    1172                 :            :     {
    1173                 :    8608760 :       next = list->next;
    1174                 :    8608760 :       update_cost_record_pool.remove (list);
    1175                 :    8608760 :       list = next;
    1176                 :            :     }
    1177                 :          0 : }
    1178                 :            : 
    1179                 :            : /* Free memory allocated for all update cost records.  */
    1180                 :            : static void
    1181                 :     688548 : finish_update_cost_records (void)
    1182                 :            : {
    1183                 :     688548 :   update_cost_record_pool.release ();
    1184                 :     688548 : }
    1185                 :            : 
    1186                 :            : /* Array whose element value is TRUE if the corresponding hard
    1187                 :            :    register was already allocated for an allocno.  */
    1188                 :            : static bool allocated_hardreg_p[FIRST_PSEUDO_REGISTER];
    1189                 :            : 
    1190                 :            : /* Describes one element in a queue of allocnos whose costs need to be
    1191                 :            :    updated.  Each allocno in the queue is known to have an allocno
    1192                 :            :    class.  */
    1193                 :            : struct update_cost_queue_elem
    1194                 :            : {
    1195                 :            :   /* This element is in the queue iff CHECK == update_cost_check.  */
    1196                 :            :   int check;
    1197                 :            : 
    1198                 :            :   /* COST_HOP_DIVISOR**N, where N is the length of the shortest path
    1199                 :            :      connecting this allocno to the one being allocated.  */
    1200                 :            :   int divisor;
    1201                 :            : 
    1202                 :            :   /* Allocno from which we started chaining costs of connected
    1203                 :            :      allocnos. */
    1204                 :            :   ira_allocno_t start;
    1205                 :            : 
    1206                 :            :   /* Allocno from which we are chaining costs of connected allocnos.
    1207                 :            :      It is used not go back in graph of allocnos connected by
    1208                 :            :      copies.  */
    1209                 :            :   ira_allocno_t from;
    1210                 :            : 
    1211                 :            :   /* The next allocno in the queue, or null if this is the last element.  */
    1212                 :            :   ira_allocno_t next;
    1213                 :            : };
    1214                 :            : 
    1215                 :            : /* The first element in a queue of allocnos whose copy costs need to be
    1216                 :            :    updated.  Null if the queue is empty.  */
    1217                 :            : static ira_allocno_t update_cost_queue;
    1218                 :            : 
    1219                 :            : /* The last element in the queue described by update_cost_queue.
    1220                 :            :    Not valid if update_cost_queue is null.  */
    1221                 :            : static struct update_cost_queue_elem *update_cost_queue_tail;
    1222                 :            : 
    1223                 :            : /* A pool of elements in the queue described by update_cost_queue.
    1224                 :            :    Elements are indexed by ALLOCNO_NUM.  */
    1225                 :            : static struct update_cost_queue_elem *update_cost_queue_elems;
    1226                 :            : 
    1227                 :            : /* The current value of update_costs_from_copies call count.  */
    1228                 :            : static int update_cost_check;
    1229                 :            : 
    1230                 :            : /* Allocate and initialize data necessary for function
    1231                 :            :    update_costs_from_copies.  */
    1232                 :            : static void
    1233                 :     688548 : initiate_cost_update (void)
    1234                 :            : {
    1235                 :     688548 :   size_t size;
    1236                 :            : 
    1237                 :     688548 :   size = ira_allocnos_num * sizeof (struct update_cost_queue_elem);
    1238                 :     688548 :   update_cost_queue_elems
    1239                 :     688548 :     = (struct update_cost_queue_elem *) ira_allocate (size);
    1240                 :     688548 :   memset (update_cost_queue_elems, 0, size);
    1241                 :     688548 :   update_cost_check = 0;
    1242                 :     688548 : }
    1243                 :            : 
    1244                 :            : /* Deallocate data used by function update_costs_from_copies.  */
    1245                 :            : static void
    1246                 :     688548 : finish_cost_update (void)
    1247                 :            : {
    1248                 :          0 :   ira_free (update_cost_queue_elems);
    1249                 :     688548 :   finish_update_cost_records ();
    1250                 :          0 : }
    1251                 :            : 
    1252                 :            : /* When we traverse allocnos to update hard register costs, the cost
    1253                 :            :    divisor will be multiplied by the following macro value for each
    1254                 :            :    hop from given allocno to directly connected allocnos.  */
    1255                 :            : #define COST_HOP_DIVISOR 4
    1256                 :            : 
    1257                 :            : /* Start a new cost-updating pass.  */
    1258                 :            : static void
    1259                 :   71342200 : start_update_cost (void)
    1260                 :            : {
    1261                 :   71342200 :   update_cost_check++;
    1262                 :   71342200 :   update_cost_queue = NULL;
    1263                 :   14670400 : }
    1264                 :            : 
    1265                 :            : /* Add (ALLOCNO, START, FROM, DIVISOR) to the end of update_cost_queue, unless
    1266                 :            :    ALLOCNO is already in the queue, or has NO_REGS class.  */
    1267                 :            : static inline void
    1268                 :  116545000 : queue_update_cost (ira_allocno_t allocno, ira_allocno_t start,
    1269                 :            :                    ira_allocno_t from, int divisor)
    1270                 :            : {
    1271                 :  116545000 :   struct update_cost_queue_elem *elem;
    1272                 :            : 
    1273                 :  116545000 :   elem = &update_cost_queue_elems[ALLOCNO_NUM (allocno)];
    1274                 :  116545000 :   if (elem->check != update_cost_check
    1275                 :   92865200 :       && ALLOCNO_CLASS (allocno) != NO_REGS)
    1276                 :            :     {
    1277                 :   92865200 :       elem->check = update_cost_check;
    1278                 :   92865200 :       elem->start = start;
    1279                 :   92865200 :       elem->from = from;
    1280                 :   92865200 :       elem->divisor = divisor;
    1281                 :   92865200 :       elem->next = NULL;
    1282                 :   92865200 :       if (update_cost_queue == NULL)
    1283                 :   34018400 :         update_cost_queue = allocno;
    1284                 :            :       else
    1285                 :   58846800 :         update_cost_queue_tail->next = allocno;
    1286                 :   92865200 :       update_cost_queue_tail = elem;
    1287                 :            :     }
    1288                 :  116545000 : }
    1289                 :            : 
    1290                 :            : /* Try to remove the first element from update_cost_queue.  Return
    1291                 :            :    false if the queue was empty, otherwise make (*ALLOCNO, *START,
    1292                 :            :    *FROM, *DIVISOR) describe the removed element.  */
    1293                 :            : static inline bool
    1294                 :  135279000 : get_next_update_cost (ira_allocno_t *allocno, ira_allocno_t *start,
    1295                 :            :                       ira_allocno_t *from, int *divisor)
    1296                 :            : {
    1297                 :  135279000 :   struct update_cost_queue_elem *elem;
    1298                 :            : 
    1299                 :  135279000 :   if (update_cost_queue == NULL)
    1300                 :            :     return false;
    1301                 :            : 
    1302                 :   82094200 :   *allocno = update_cost_queue;
    1303                 :   82094200 :   elem = &update_cost_queue_elems[ALLOCNO_NUM (*allocno)];
    1304                 :   82094200 :   *start = elem->start;
    1305                 :   82094200 :   *from = elem->from;
    1306                 :   82094200 :   *divisor = elem->divisor;
    1307                 :   82094200 :   update_cost_queue = elem->next;
    1308                 :   82094200 :   return true;
    1309                 :            : }
    1310                 :            : 
    1311                 :            : /* Increase costs of HARD_REGNO by UPDATE_COST and conflict cost by
    1312                 :            :    UPDATE_CONFLICT_COST for ALLOCNO.  Return true if we really
    1313                 :            :    modified the cost.  */
    1314                 :            : static bool
    1315                 :   13680100 : update_allocno_cost (ira_allocno_t allocno, int hard_regno,
    1316                 :            :                      int update_cost, int update_conflict_cost)
    1317                 :            : {
    1318                 :   13680100 :   int i;
    1319                 :   13680100 :   enum reg_class aclass = ALLOCNO_CLASS (allocno);
    1320                 :            : 
    1321                 :   13680100 :   i = ira_class_hard_reg_index[aclass][hard_regno];
    1322                 :   13680100 :   if (i < 0)
    1323                 :            :     return false;
    1324                 :   13680100 :   ira_allocate_and_set_or_copy_costs
    1325                 :   13680100 :     (&ALLOCNO_UPDATED_HARD_REG_COSTS (allocno), aclass,
    1326                 :            :      ALLOCNO_UPDATED_CLASS_COST (allocno),
    1327                 :            :      ALLOCNO_HARD_REG_COSTS (allocno));
    1328                 :   13680100 :   ira_allocate_and_set_or_copy_costs
    1329                 :   13680100 :     (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (allocno),
    1330                 :            :      aclass, 0, ALLOCNO_CONFLICT_HARD_REG_COSTS (allocno));
    1331                 :   13680100 :   ALLOCNO_UPDATED_HARD_REG_COSTS (allocno)[i] += update_cost;
    1332                 :   13680100 :   ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (allocno)[i] += update_conflict_cost;
    1333                 :   13680100 :   return true;
    1334                 :            : }
    1335                 :            : 
    1336                 :            : /* Return TRUE if allocnos A1 and A2 conflicts. Here we are
    1337                 :            :    interesting only in conflicts of allocnos with intersected allocno
    1338                 :            :    classes. */
    1339                 :            : static bool
    1340                 :   85863300 : allocnos_conflict_p (ira_allocno_t a1, ira_allocno_t a2)
    1341                 :            : {
    1342                 :   85863300 :   ira_object_t obj, conflict_obj;
    1343                 :   85863300 :   ira_object_conflict_iterator oci;
    1344                 :   85863300 :   int word, nwords = ALLOCNO_NUM_OBJECTS (a1);
    1345                 :            :   
    1346                 :  171136000 :   for (word = 0; word < nwords; word++)
    1347                 :            :     {
    1348                 :   87040200 :       obj = ALLOCNO_OBJECT (a1, word);
    1349                 :            :       /* Take preferences of conflicting allocnos into account.  */
    1350                 : 4107240000 :       FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    1351                 : 4021970000 :         if (OBJECT_ALLOCNO (conflict_obj) == a2)
    1352                 :            :           return true;
    1353                 :            :     }
    1354                 :            :   return false;
    1355                 :            : }  
    1356                 :            : 
    1357                 :            : /* Update (decrease if DECR_P) HARD_REGNO cost of allocnos connected
    1358                 :            :    by copies to ALLOCNO to increase chances to remove some copies as
    1359                 :            :    the result of subsequent assignment.  Update conflict costs only
    1360                 :            :    for true CONFLICT_COST_UPDATE_P.  Record cost updates if RECORD_P is
    1361                 :            :    true.  */
    1362                 :            : static void
    1363                 :   25928600 : update_costs_from_allocno (ira_allocno_t allocno, int hard_regno,
    1364                 :            :                            int divisor, bool decr_p, bool record_p,
    1365                 :            :                            bool conflict_cost_update_p)
    1366                 :            : {
    1367                 :   25928600 :   int cost, update_cost, update_conflict_cost;
    1368                 :   25928600 :   machine_mode mode;
    1369                 :   25928600 :   enum reg_class rclass, aclass;
    1370                 :   25928600 :   ira_allocno_t another_allocno, start = allocno, from = NULL;
    1371                 :   25928600 :   ira_copy_t cp, next_cp;
    1372                 :            : 
    1373                 :   25928600 :   rclass = REGNO_REG_CLASS (hard_regno);
    1374                 :   38017500 :   do
    1375                 :            :     {
    1376                 :   38017500 :       mode = ALLOCNO_MODE (allocno);
    1377                 :   38017500 :       ira_init_register_move_cost_if_necessary (mode);
    1378                 :   81260000 :       for (cp = ALLOCNO_COPIES (allocno); cp != NULL; cp = next_cp)
    1379                 :            :         {
    1380                 :   43242500 :           if (cp->first == allocno)
    1381                 :            :             {
    1382                 :   19844100 :               next_cp = cp->next_first_allocno_copy;
    1383                 :   19844100 :               another_allocno = cp->second;
    1384                 :            :             }
    1385                 :   23398500 :           else if (cp->second == allocno)
    1386                 :            :             {
    1387                 :   23398500 :               next_cp = cp->next_second_allocno_copy;
    1388                 :   23398500 :               another_allocno = cp->first;
    1389                 :            :             }
    1390                 :            :           else
    1391                 :          0 :             gcc_unreachable ();
    1392                 :            : 
    1393                 :   56220400 :           if (another_allocno == from
    1394                 :   43242500 :               || allocnos_conflict_p (another_allocno, start))
    1395                 :   12977900 :             continue;
    1396                 :            : 
    1397                 :   30264700 :           aclass = ALLOCNO_CLASS (another_allocno);
    1398                 :   30264700 :           if (! TEST_HARD_REG_BIT (reg_class_contents[aclass],
    1399                 :            :                                    hard_regno)
    1400                 :   30264700 :               || ALLOCNO_ASSIGNED_P (another_allocno))
    1401                 :   15190600 :             continue;
    1402                 :            : 
    1403                 :            :           /* If we have different modes use the smallest one.  It is
    1404                 :            :              a sub-register move.  It is hard to predict what LRA
    1405                 :            :              will reload (the pseudo or its sub-register) but LRA
    1406                 :            :              will try to minimize the data movement.  Also for some
    1407                 :            :              register classes bigger modes might be invalid,
    1408                 :            :              e.g. DImode for AREG on x86.  For such cases the
    1409                 :            :              register move cost will be maximal.  */
    1410                 :   15074100 :           mode = narrower_subreg_mode (mode, ALLOCNO_MODE (cp->second));
    1411                 :   15074100 :           ira_init_register_move_cost_if_necessary (mode);
    1412                 :            :           
    1413                 :   30148200 :           cost = (cp->second == allocno
    1414                 :   15074100 :                   ? ira_register_move_cost[mode][rclass][aclass]
    1415                 :   10699000 :                   : ira_register_move_cost[mode][aclass][rclass]);
    1416                 :   15074100 :           if (decr_p)
    1417                 :   15074100 :             cost = -cost;
    1418                 :            : 
    1419                 :   15074100 :           update_cost = cp->freq * cost / divisor;
    1420                 :   15074100 :           update_conflict_cost = conflict_cost_update_p ? update_cost : 0;
    1421                 :            : 
    1422                 :   15074100 :           if (ALLOCNO_COLOR_DATA (another_allocno) != NULL
    1423                 :   14792100 :               && (ALLOCNO_COLOR_DATA (allocno)->first_thread_allocno
    1424                 :   14792100 :                   != ALLOCNO_COLOR_DATA (another_allocno)->first_thread_allocno))
    1425                 :            :             /* Decrease conflict cost of ANOTHER_ALLOCNO if it is not
    1426                 :            :                in the same allocation thread.  */
    1427                 :    5287960 :             update_conflict_cost /= COST_HOP_DIVISOR;
    1428                 :            : 
    1429                 :   15074100 :           if (update_cost == 0)
    1430                 :    1393980 :             continue;
    1431                 :            : 
    1432                 :   13680100 :           if (! update_allocno_cost (another_allocno, hard_regno,
    1433                 :            :                                      update_cost, update_conflict_cost))
    1434                 :          0 :             continue;
    1435                 :   13680100 :           queue_update_cost (another_allocno, start, allocno,
    1436                 :            :                              divisor * COST_HOP_DIVISOR);
    1437                 :   13680100 :           if (record_p && ALLOCNO_COLOR_DATA (another_allocno) != NULL)
    1438                 :    8609780 :             ALLOCNO_COLOR_DATA (another_allocno)->update_cost_records
    1439                 :    8609780 :               = get_update_cost_record (hard_regno, divisor,
    1440                 :            :                                         ALLOCNO_COLOR_DATA (another_allocno)
    1441                 :            :                                         ->update_cost_records);
    1442                 :            :         }
    1443                 :            :     }
    1444                 :   50106400 :   while (get_next_update_cost (&allocno, &start, &from, &divisor));
    1445                 :   25928600 : }
    1446                 :            : 
    1447                 :            : /* Decrease preferred ALLOCNO hard register costs and costs of
    1448                 :            :    allocnos connected to ALLOCNO through copy.  */
    1449                 :            : static void
    1450                 :   14476100 : update_costs_from_prefs (ira_allocno_t allocno)
    1451                 :            : {
    1452                 :   14476100 :   ira_pref_t pref;
    1453                 :            : 
    1454                 :   14476100 :   start_update_cost ();
    1455                 :   17898900 :   for (pref = ALLOCNO_PREFS (allocno); pref != NULL; pref = pref->next_pref)
    1456                 :    3422740 :     update_costs_from_allocno (allocno, pref->hard_regno,
    1457                 :            :                                COST_HOP_DIVISOR, true, true, false);
    1458                 :   14476100 : }
    1459                 :            : 
    1460                 :            : /* Update (decrease if DECR_P) the cost of allocnos connected to
    1461                 :            :    ALLOCNO through copies to increase chances to remove some copies as
    1462                 :            :    the result of subsequent assignment.  ALLOCNO was just assigned to
    1463                 :            :    a hard register.  Record cost updates if RECORD_P is true.  */
    1464                 :            : static void
    1465                 :   13897100 : update_costs_from_copies (ira_allocno_t allocno, bool decr_p, bool record_p)
    1466                 :            : {
    1467                 :   13897100 :   int hard_regno;
    1468                 :            : 
    1469                 :   13897100 :   hard_regno = ALLOCNO_HARD_REGNO (allocno);
    1470                 :   13897100 :   ira_assert (hard_regno >= 0 && ALLOCNO_CLASS (allocno) != NO_REGS);
    1471                 :   13897100 :   start_update_cost ();
    1472                 :   13897100 :   update_costs_from_allocno (allocno, hard_regno, 1, decr_p, record_p, true);
    1473                 :   13897100 : }
    1474                 :            : 
    1475                 :            : /* Update conflict_allocno_hard_prefs of allocnos conflicting with
    1476                 :            :    ALLOCNO.  */
    1477                 :            : static void
    1478                 :   14476100 : update_conflict_allocno_hard_prefs (ira_allocno_t allocno)
    1479                 :            : {
    1480                 :   14476100 :   int l, nr = ALLOCNO_NUM_OBJECTS (allocno);
    1481                 :            :   
    1482                 :   29212000 :   for (l = 0; l < nr; l++)
    1483                 :            :     {
    1484                 :   14735900 :       ira_object_t conflict_obj, obj = ALLOCNO_OBJECT (allocno, l);
    1485                 :   14735900 :       ira_object_conflict_iterator oci;
    1486                 :            :       
    1487                 :  398606000 :       FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    1488                 :            :         {
    1489                 :  383870000 :           ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    1490                 :  383870000 :           allocno_color_data_t conflict_data = ALLOCNO_COLOR_DATA (conflict_a);
    1491                 :  383870000 :           ira_pref_t pref;
    1492                 :            : 
    1493                 :  821744000 :           if (!(hard_reg_set_intersect_p
    1494                 :  383870000 :                 (ALLOCNO_COLOR_DATA (allocno)->profitable_hard_regs,
    1495                 :  383870000 :                  conflict_data->profitable_hard_regs)))
    1496                 :   54004300 :             continue;
    1497                 :  329866000 :           for (pref = ALLOCNO_PREFS (allocno);
    1498                 :  349371000 :                pref != NULL;
    1499                 :   19505400 :                pref = pref->next_pref)
    1500                 :   19505400 :             conflict_data->conflict_allocno_hard_prefs += pref->freq;
    1501                 :            :         }
    1502                 :            :     }
    1503                 :   14476100 : }
    1504                 :            : 
    1505                 :            : /* Restore costs of allocnos connected to ALLOCNO by copies as it was
    1506                 :            :    before updating costs of these allocnos from given allocno.  This
    1507                 :            :    is a wise thing to do as if given allocno did not get an expected
    1508                 :            :    hard reg, using smaller cost of the hard reg for allocnos connected
    1509                 :            :    by copies to given allocno becomes actually misleading.  Free all
    1510                 :            :    update cost records for ALLOCNO as we don't need them anymore.  */
    1511                 :            : static void
    1512                 :   14670400 : restore_costs_from_copies (ira_allocno_t allocno)
    1513                 :            : {
    1514                 :   14670400 :   struct update_cost_record *records, *curr;
    1515                 :            : 
    1516                 :   14670400 :   if (ALLOCNO_COLOR_DATA (allocno) == NULL)
    1517                 :            :     return;
    1518                 :   14670400 :   records = ALLOCNO_COLOR_DATA (allocno)->update_cost_records;
    1519                 :   14670400 :   start_update_cost ();
    1520                 :   23279100 :   for (curr = records; curr != NULL; curr = curr->next)
    1521                 :    8608760 :     update_costs_from_allocno (allocno, curr->hard_regno,
    1522                 :            :                                curr->divisor, true, false, true);
    1523                 :   14670400 :   free_update_cost_record_list (records);
    1524                 :   14670400 :   ALLOCNO_COLOR_DATA (allocno)->update_cost_records = NULL;
    1525                 :            : }
    1526                 :            : 
    1527                 :            : /* This function updates COSTS (decrease if DECR_P) for hard_registers
    1528                 :            :    of ACLASS by conflict costs of the unassigned allocnos
    1529                 :            :    connected by copies with allocnos in update_cost_queue.  This
    1530                 :            :    update increases chances to remove some copies.  */
    1531                 :            : static void
    1532                 :   27256400 : update_conflict_hard_regno_costs (int *costs, enum reg_class aclass,
    1533                 :            :                                   bool decr_p)
    1534                 :            : {
    1535                 :   97261700 :   int i, cost, class_size, freq, mult, div, divisor;
    1536                 :   97261700 :   int index, hard_regno;
    1537                 :   97261700 :   int *conflict_costs;
    1538                 :   97261700 :   bool cont_p;
    1539                 :   97261700 :   enum reg_class another_aclass;
    1540                 :   97261700 :   ira_allocno_t allocno, another_allocno, start, from;
    1541                 :   97261700 :   ira_copy_t cp, next_cp;
    1542                 :            : 
    1543                 :  167267000 :   while (get_next_update_cost (&allocno, &start, &from, &divisor))
    1544                 :  124744000 :     for (cp = ALLOCNO_COPIES (allocno); cp != NULL; cp = next_cp)
    1545                 :            :       {
    1546                 :   54738900 :         if (cp->first == allocno)
    1547                 :            :           {
    1548                 :   26005100 :             next_cp = cp->next_first_allocno_copy;
    1549                 :   26005100 :             another_allocno = cp->second;
    1550                 :            :           }
    1551                 :   28733900 :         else if (cp->second == allocno)
    1552                 :            :           {
    1553                 :   28733900 :             next_cp = cp->next_second_allocno_copy;
    1554                 :   28733900 :             another_allocno = cp->first;
    1555                 :            :           }
    1556                 :            :         else
    1557                 :          0 :           gcc_unreachable ();
    1558                 :            : 
    1559                 :   55646600 :         if (another_allocno == from
    1560                 :   54738900 :             || allocnos_conflict_p (another_allocno, start))
    1561                 :     907664 :           continue;
    1562                 :            : 
    1563                 :   53831300 :         another_aclass = ALLOCNO_CLASS (another_allocno);
    1564                 :   53831300 :         if (! ira_reg_classes_intersect_p[aclass][another_aclass]
    1565                 :   51864400 :             || ALLOCNO_ASSIGNED_P (another_allocno)
    1566                 :   43256400 :             || ALLOCNO_COLOR_DATA (another_allocno)->may_be_spilled_p)
    1567                 :   12672600 :           continue;
    1568                 :   41158700 :         class_size = ira_class_hard_regs_num[another_aclass];
    1569                 :   41158700 :         ira_allocate_and_copy_costs
    1570                 :   41158700 :           (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (another_allocno),
    1571                 :            :            another_aclass, ALLOCNO_CONFLICT_HARD_REG_COSTS (another_allocno));
    1572                 :   41158700 :         conflict_costs
    1573                 :   41158700 :           = ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (another_allocno);
    1574                 :   41158700 :         if (conflict_costs == NULL)
    1575                 :            :           cont_p = true;
    1576                 :            :         else
    1577                 :            :           {
    1578                 :   14394900 :             mult = cp->freq;
    1579                 :   14394900 :             freq = ALLOCNO_FREQ (another_allocno);
    1580                 :   14394900 :             if (freq == 0)
    1581                 :          0 :               freq = 1;
    1582                 :   14394900 :             div = freq * divisor;
    1583                 :   14394900 :             cont_p = false;
    1584                 :  248779000 :             for (i = class_size - 1; i >= 0; i--)
    1585                 :            :               {
    1586                 :  234384000 :                 hard_regno = ira_class_hard_regs[another_aclass][i];
    1587                 :  234384000 :                 ira_assert (hard_regno >= 0);
    1588                 :  234384000 :                 index = ira_class_hard_reg_index[aclass][hard_regno];
    1589                 :  234384000 :                 if (index < 0)
    1590                 :    6363530 :                   continue;
    1591                 :  228020000 :                 cost = (int) (((int64_t) conflict_costs [i] * mult) / div);
    1592                 :  228020000 :                 if (cost == 0)
    1593                 :  222988000 :                   continue;
    1594                 :    5032040 :                 cont_p = true;
    1595                 :    5032040 :                 if (decr_p)
    1596                 :    3408730 :                   cost = -cost;
    1597                 :    5032040 :                 costs[index] += cost;
    1598                 :            :               }
    1599                 :            :           }
    1600                 :            :         /* Probably 5 hops will be enough.  */
    1601                 :   14394900 :         if (cont_p
    1602                 :   31039000 :             && divisor <= (COST_HOP_DIVISOR
    1603                 :            :                            * COST_HOP_DIVISOR
    1604                 :            :                            * COST_HOP_DIVISOR
    1605                 :            :                            * COST_HOP_DIVISOR))
    1606                 :   30535800 :           queue_update_cost (another_allocno, start, from, divisor * COST_HOP_DIVISOR);
    1607                 :            :       }
    1608                 :   27256400 : }
    1609                 :            : 
    1610                 :            : /* Set up conflicting (through CONFLICT_REGS) for each object of
    1611                 :            :    allocno A and the start allocno profitable regs (through
    1612                 :            :    START_PROFITABLE_REGS).  Remember that the start profitable regs
    1613                 :            :    exclude hard regs which cannot hold value of mode of allocno A.
    1614                 :            :    This covers mostly cases when multi-register value should be
    1615                 :            :    aligned.  */
    1616                 :            : static inline void
    1617                 :   21410800 : get_conflict_and_start_profitable_regs (ira_allocno_t a, bool retry_p,
    1618                 :            :                                         HARD_REG_SET *conflict_regs,
    1619                 :            :                                         HARD_REG_SET *start_profitable_regs)
    1620                 :            : {
    1621                 :   21410800 :   int i, nwords;
    1622                 :   21410800 :   ira_object_t obj;
    1623                 :            : 
    1624                 :   21410800 :   nwords = ALLOCNO_NUM_OBJECTS (a);
    1625                 :   43345700 :   for (i = 0; i < nwords; i++)
    1626                 :            :     {
    1627                 :   21934900 :       obj = ALLOCNO_OBJECT (a, i);
    1628                 :   21934900 :       conflict_regs[i] = OBJECT_TOTAL_CONFLICT_HARD_REGS (obj);
    1629                 :            :     }
    1630                 :   21410800 :   if (retry_p)
    1631                 :          0 :     *start_profitable_regs
    1632                 :          0 :       = (reg_class_contents[ALLOCNO_CLASS (a)]
    1633                 :          0 :          &~ (ira_prohibited_class_mode_regs
    1634                 :          0 :              [ALLOCNO_CLASS (a)][ALLOCNO_MODE (a)]));
    1635                 :            :   else
    1636                 :   21410800 :     *start_profitable_regs = ALLOCNO_COLOR_DATA (a)->profitable_hard_regs;
    1637                 :   21410800 : }
    1638                 :            : 
    1639                 :            : /* Return true if HARD_REGNO is ok for assigning to allocno A with
    1640                 :            :    PROFITABLE_REGS and whose objects have CONFLICT_REGS.  */
    1641                 :            : static inline bool
    1642                 :  401161000 : check_hard_reg_p (ira_allocno_t a, int hard_regno,
    1643                 :            :                   HARD_REG_SET *conflict_regs, HARD_REG_SET profitable_regs)
    1644                 :            : {
    1645                 :  401161000 :   int j, nwords, nregs;
    1646                 :  401161000 :   enum reg_class aclass;
    1647                 :  401161000 :   machine_mode mode;
    1648                 :            : 
    1649                 :  401161000 :   aclass = ALLOCNO_CLASS (a);
    1650                 :  401161000 :   mode = ALLOCNO_MODE (a);
    1651                 :  401161000 :   if (TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[aclass][mode],
    1652                 :            :                          hard_regno))
    1653                 :            :     return false;
    1654                 :            :   /* Checking only profitable hard regs.  */
    1655                 :  400571000 :   if (! TEST_HARD_REG_BIT (profitable_regs, hard_regno))
    1656                 :            :     return false;
    1657                 :  330069000 :   nregs = hard_regno_nregs (hard_regno, mode);
    1658                 :  330069000 :   nwords = ALLOCNO_NUM_OBJECTS (a);
    1659                 :  621230000 :   for (j = 0; j < nregs; j++)
    1660                 :            :     {
    1661                 :  336361000 :       int k;
    1662                 :  336361000 :       int set_to_test_start = 0, set_to_test_end = nwords;
    1663                 :            :       
    1664                 :  336361000 :       if (nregs == nwords)
    1665                 :            :         {
    1666                 :  336299000 :           if (REG_WORDS_BIG_ENDIAN)
    1667                 :            :             set_to_test_start = nwords - j - 1;
    1668                 :            :           else
    1669                 :  336299000 :             set_to_test_start = j;
    1670                 :  336299000 :           set_to_test_end = set_to_test_start + 1;
    1671                 :            :         }
    1672                 :  627562000 :       for (k = set_to_test_start; k < set_to_test_end; k++)
    1673                 :  336400000 :         if (TEST_HARD_REG_BIT (conflict_regs[k], hard_regno + j))
    1674                 :            :           break;
    1675                 :  336361000 :       if (k != set_to_test_end)
    1676                 :            :         break;
    1677                 :            :     }
    1678                 :  330069000 :   return j == nregs;
    1679                 :            : }
    1680                 :            : 
    1681                 :            : /* Return number of registers needed to be saved and restored at
    1682                 :            :    function prologue/epilogue if we allocate HARD_REGNO to hold value
    1683                 :            :    of MODE.  */
    1684                 :            : static int
    1685                 :  133621000 : calculate_saved_nregs (int hard_regno, machine_mode mode)
    1686                 :            : {
    1687                 :  133621000 :   int i;
    1688                 :  133621000 :   int nregs = 0;
    1689                 :            : 
    1690                 :  133621000 :   ira_assert (hard_regno >= 0);
    1691                 :  268524000 :   for (i = hard_regno_nregs (hard_regno, mode) - 1; i >= 0; i--)
    1692                 :  134903000 :     if (!allocated_hardreg_p[hard_regno + i]
    1693                 :   78802400 :         && !crtl->abi->clobbers_full_reg_p (hard_regno + i)
    1694                 :  134903000 :         && !LOCAL_REGNO (hard_regno + i))
    1695                 :   26246400 :       nregs++;
    1696                 :  133621000 :   return nregs;
    1697                 :            : }
    1698                 :            : 
    1699                 :            : /* Choose a hard register for allocno A.  If RETRY_P is TRUE, it means
    1700                 :            :    that the function called from function
    1701                 :            :    `ira_reassign_conflict_allocnos' and `allocno_reload_assign'.  In
    1702                 :            :    this case some allocno data are not defined or updated and we
    1703                 :            :    should not touch these data.  The function returns true if we
    1704                 :            :    managed to assign a hard register to the allocno.
    1705                 :            : 
    1706                 :            :    To assign a hard register, first of all we calculate all conflict
    1707                 :            :    hard registers which can come from conflicting allocnos with
    1708                 :            :    already assigned hard registers.  After that we find first free
    1709                 :            :    hard register with the minimal cost.  During hard register cost
    1710                 :            :    calculation we take conflict hard register costs into account to
    1711                 :            :    give a chance for conflicting allocnos to get a better hard
    1712                 :            :    register in the future.
    1713                 :            : 
    1714                 :            :    If the best hard register cost is bigger than cost of memory usage
    1715                 :            :    for the allocno, we don't assign a hard register to given allocno
    1716                 :            :    at all.
    1717                 :            : 
    1718                 :            :    If we assign a hard register to the allocno, we update costs of the
    1719                 :            :    hard register for allocnos connected by copies to improve a chance
    1720                 :            :    to coalesce insns represented by the copies when we assign hard
    1721                 :            :    registers to the allocnos connected by the copies.  */
    1722                 :            : static bool
    1723                 :   14670400 : assign_hard_reg (ira_allocno_t a, bool retry_p)
    1724                 :            : {
    1725                 :   14670400 :   HARD_REG_SET conflicting_regs[2], profitable_hard_regs;
    1726                 :   14670400 :   int i, j, hard_regno, best_hard_regno, class_size;
    1727                 :   14670400 :   int cost, mem_cost, min_cost, full_cost, min_full_cost, nwords, word;
    1728                 :   14670400 :   int *a_costs;
    1729                 :   14670400 :   enum reg_class aclass;
    1730                 :   14670400 :   machine_mode mode;
    1731                 :   14670400 :   static int costs[FIRST_PSEUDO_REGISTER], full_costs[FIRST_PSEUDO_REGISTER];
    1732                 :   14670400 :   int saved_nregs;
    1733                 :   14670400 :   enum reg_class rclass;
    1734                 :   14670400 :   int add_cost;
    1735                 :            : #ifdef STACK_REGS
    1736                 :   14670400 :   bool no_stack_reg_p;
    1737                 :            : #endif
    1738                 :            : 
    1739                 :   14670400 :   ira_assert (! ALLOCNO_ASSIGNED_P (a));
    1740                 :   14670400 :   get_conflict_and_start_profitable_regs (a, retry_p,
    1741                 :            :                                           conflicting_regs,
    1742                 :            :                                           &profitable_hard_regs);
    1743                 :   14670400 :   aclass = ALLOCNO_CLASS (a);
    1744                 :   14670400 :   class_size = ira_class_hard_regs_num[aclass];
    1745                 :   14670400 :   best_hard_regno = -1;
    1746                 :   14670400 :   memset (full_costs, 0, sizeof (int) * class_size);
    1747                 :   14670400 :   mem_cost = 0;
    1748                 :   14670400 :   memset (costs, 0, sizeof (int) * class_size);
    1749                 :   14670400 :   memset (full_costs, 0, sizeof (int) * class_size);
    1750                 :            : #ifdef STACK_REGS
    1751                 :   14670400 :   no_stack_reg_p = false;
    1752                 :            : #endif
    1753                 :   14670400 :   if (! retry_p)
    1754                 :   14670400 :     start_update_cost ();
    1755                 :   14670400 :   mem_cost += ALLOCNO_UPDATED_MEMORY_COST (a);
    1756                 :            :   
    1757                 :   14670400 :   ira_allocate_and_copy_costs (&ALLOCNO_UPDATED_HARD_REG_COSTS (a),
    1758                 :            :                                aclass, ALLOCNO_HARD_REG_COSTS (a));
    1759                 :   14670400 :   a_costs = ALLOCNO_UPDATED_HARD_REG_COSTS (a);
    1760                 :            : #ifdef STACK_REGS
    1761                 :   14670400 :   no_stack_reg_p = no_stack_reg_p || ALLOCNO_TOTAL_NO_STACK_REG_P (a);
    1762                 :            : #endif
    1763                 :   14670400 :   cost = ALLOCNO_UPDATED_CLASS_COST (a);
    1764                 :  217131000 :   for (i = 0; i < class_size; i++)
    1765                 :  202461000 :     if (a_costs != NULL)
    1766                 :            :       {
    1767                 :  138705000 :         costs[i] += a_costs[i];
    1768                 :  138705000 :         full_costs[i] += a_costs[i];
    1769                 :            :       }
    1770                 :            :     else
    1771                 :            :       {
    1772                 :   63755500 :         costs[i] += cost;
    1773                 :   63755500 :         full_costs[i] += cost;
    1774                 :            :       }
    1775                 :   14670400 :   nwords = ALLOCNO_NUM_OBJECTS (a);
    1776                 :   14670400 :   curr_allocno_process++;
    1777                 :   28516000 :   for (word = 0; word < nwords; word++)
    1778                 :            :     {
    1779                 :   14887800 :       ira_object_t conflict_obj;
    1780                 :   14887800 :       ira_object_t obj = ALLOCNO_OBJECT (a, word);
    1781                 :   14887800 :       ira_object_conflict_iterator oci;
    1782                 :            :       
    1783                 :            :       /* Take preferences of conflicting allocnos into account.  */
    1784                 :  329531000 :       FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    1785                 :            :         {
    1786                 :  315685000 :           ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    1787                 :  315685000 :           enum reg_class conflict_aclass;
    1788                 :  315685000 :           allocno_color_data_t data = ALLOCNO_COLOR_DATA (conflict_a);
    1789                 :            : 
    1790                 :            :           /* Reload can give another class so we need to check all
    1791                 :            :              allocnos.  */
    1792                 :  368597000 :           if (!retry_p
    1793                 :  315685000 :               && ((!ALLOCNO_ASSIGNED_P (conflict_a)
    1794                 :  183479000 :                    || ALLOCNO_HARD_REGNO (conflict_a) < 0)
    1795                 :  244780000 :                   && !(hard_reg_set_intersect_p
    1796                 :  244780000 :                        (profitable_hard_regs,
    1797                 :            :                         ALLOCNO_COLOR_DATA
    1798                 :  734340000 :                         (conflict_a)->profitable_hard_regs))))
    1799                 :            :             {
    1800                 :            :               /* All conflict allocnos are in consideration bitmap
    1801                 :            :                  when retry_p is false.  It might change in future and
    1802                 :            :                  if it happens the assert will be broken.  It means
    1803                 :            :                  the code should be modified for the new
    1804                 :            :                  assumptions.  */
    1805                 :   52912100 :               ira_assert (bitmap_bit_p (consideration_allocno_bitmap,
    1806                 :            :                                         ALLOCNO_NUM (conflict_a)));
    1807                 :   52912100 :               continue;
    1808                 :            :             }
    1809                 :  262773000 :           conflict_aclass = ALLOCNO_CLASS (conflict_a);
    1810                 :  262773000 :           ira_assert (ira_reg_classes_intersect_p
    1811                 :            :                       [aclass][conflict_aclass]);
    1812                 :  262773000 :           if (ALLOCNO_ASSIGNED_P (conflict_a))
    1813                 :            :             {
    1814                 :  130867000 :               hard_regno = ALLOCNO_HARD_REGNO (conflict_a);
    1815                 :  130867000 :               if (hard_regno >= 0
    1816                 :  201772000 :                   && (ira_hard_reg_set_intersection_p
    1817                 :   70905200 :                       (hard_regno, ALLOCNO_MODE (conflict_a),
    1818                 :            :                        reg_class_contents[aclass])))
    1819                 :            :                 {
    1820                 :   70257700 :                   int n_objects = ALLOCNO_NUM_OBJECTS (conflict_a);
    1821                 :   70257700 :                   int conflict_nregs;
    1822                 :            : 
    1823                 :   70257700 :                   mode = ALLOCNO_MODE (conflict_a);
    1824                 :   70257700 :                   conflict_nregs = hard_regno_nregs (hard_regno, mode);
    1825                 :   70257700 :                   if (conflict_nregs == n_objects && conflict_nregs > 1)
    1826                 :            :                     {
    1827                 :    1396500 :                       int num = OBJECT_SUBWORD (conflict_obj);
    1828                 :            : 
    1829                 :    1396500 :                       if (REG_WORDS_BIG_ENDIAN)
    1830                 :            :                         SET_HARD_REG_BIT (conflicting_regs[word],
    1831                 :            :                                           hard_regno + n_objects - num - 1);
    1832                 :            :                       else
    1833                 :   71654200 :                         SET_HARD_REG_BIT (conflicting_regs[word],
    1834                 :    1396500 :                                           hard_regno + num);
    1835                 :            :                     }
    1836                 :            :                   else
    1837                 :   68861200 :                     conflicting_regs[word]
    1838                 :   68861200 :                       |= ira_reg_mode_hard_regset[hard_regno][mode];
    1839                 :   70257700 :                   if (hard_reg_set_subset_p (profitable_hard_regs,
    1840                 :   70257700 :                                              conflicting_regs[word]))
    1841                 :    1042160 :                     goto fail;
    1842                 :            :                 }
    1843                 :            :             }
    1844                 :  131906000 :           else if (! retry_p
    1845                 :  131906000 :                    && ! ALLOCNO_COLOR_DATA (conflict_a)->may_be_spilled_p
    1846                 :            :                    /* Don't process the conflict allocno twice.  */
    1847                 :   59640200 :                    && (ALLOCNO_COLOR_DATA (conflict_a)->last_process
    1848                 :   59640200 :                        != curr_allocno_process))
    1849                 :            :             {
    1850                 :   58701000 :               int k, *conflict_costs;
    1851                 :            :               
    1852                 :   58701000 :               ALLOCNO_COLOR_DATA (conflict_a)->last_process
    1853                 :   58701000 :                 = curr_allocno_process;
    1854                 :   58701000 :               ira_allocate_and_copy_costs
    1855                 :   58701000 :                 (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_a),
    1856                 :            :                  conflict_aclass,
    1857                 :            :                  ALLOCNO_CONFLICT_HARD_REG_COSTS (conflict_a));
    1858                 :   58701000 :               conflict_costs
    1859                 :   58701000 :                 = ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_a);
    1860                 :   58701000 :               if (conflict_costs != NULL)
    1861                 :  280059000 :                 for (j = class_size - 1; j >= 0; j--)
    1862                 :            :                   {
    1863                 :  263193000 :                     hard_regno = ira_class_hard_regs[aclass][j];
    1864                 :  263193000 :                     ira_assert (hard_regno >= 0);
    1865                 :  263193000 :                     k = ira_class_hard_reg_index[conflict_aclass][hard_regno];
    1866                 :  286360000 :                     if (k < 0
    1867                 :            :                            /* If HARD_REGNO is not available for CONFLICT_A,
    1868                 :            :                               the conflict would be ignored, since HARD_REGNO
    1869                 :            :                               will never be assigned to CONFLICT_A.  */
    1870                 :  263193000 :                         || !TEST_HARD_REG_BIT (data->profitable_hard_regs,
    1871                 :            :                                                hard_regno))
    1872                 :   23167200 :                       continue;
    1873                 :  240025000 :                     full_costs[j] -= conflict_costs[k];
    1874                 :            :                   }
    1875                 :   58701000 :               queue_update_cost (conflict_a, conflict_a, NULL, COST_HOP_DIVISOR);
    1876                 :            :             }
    1877                 :            :         }
    1878                 :            :     }
    1879                 :   13628200 :   if (! retry_p)
    1880                 :            :     /* Take into account preferences of allocnos connected by copies to
    1881                 :            :        the conflict allocnos.  */
    1882                 :   13628200 :     update_conflict_hard_regno_costs (full_costs, aclass, true);
    1883                 :            : 
    1884                 :            :   /* Take preferences of allocnos connected by copies into
    1885                 :            :      account.  */
    1886                 :   13628200 :   if (! retry_p)
    1887                 :            :     {
    1888                 :   13628200 :       start_update_cost ();
    1889                 :   13628200 :       queue_update_cost (a, a, NULL, COST_HOP_DIVISOR);
    1890                 :   13628200 :       update_conflict_hard_regno_costs (full_costs, aclass, false);
    1891                 :            :     }
    1892                 :   13628200 :   min_cost = min_full_cost = INT_MAX;
    1893                 :            :   /* We don't care about giving callee saved registers to allocnos no
    1894                 :            :      living through calls because call clobbered registers are
    1895                 :            :      allocated first (it is usual practice to put them first in
    1896                 :            :      REG_ALLOC_ORDER).  */
    1897                 :   13628200 :   mode = ALLOCNO_MODE (a);
    1898                 :  204776000 :   for (i = 0; i < class_size; i++)
    1899                 :            :     {
    1900                 :  191148000 :       hard_regno = ira_class_hard_regs[aclass][i];
    1901                 :            : #ifdef STACK_REGS
    1902                 :  191148000 :       if (no_stack_reg_p
    1903                 :  191148000 :           && FIRST_STACK_REG <= hard_regno && hard_regno <= LAST_STACK_REG)
    1904                 :          0 :         continue;
    1905                 :            : #endif
    1906                 :  191148000 :       if (! check_hard_reg_p (a, hard_regno,
    1907                 :            :                               conflicting_regs, profitable_hard_regs))
    1908                 :   57526500 :         continue;
    1909                 :  133621000 :       cost = costs[i];
    1910                 :  133621000 :       full_cost = full_costs[i];
    1911                 :  133621000 :       if (!HONOR_REG_ALLOC_ORDER)
    1912                 :            :         {
    1913                 :  133621000 :           if ((saved_nregs = calculate_saved_nregs (hard_regno, mode)) != 0)
    1914                 :            :           /* We need to save/restore the hard register in
    1915                 :            :              epilogue/prologue.  Therefore we increase the cost.  */
    1916                 :            :           {
    1917                 :   26039300 :             rclass = REGNO_REG_CLASS (hard_regno);
    1918                 :   26039300 :             add_cost = ((ira_memory_move_cost[mode][rclass][0]
    1919                 :   26039300 :                          + ira_memory_move_cost[mode][rclass][1])
    1920                 :   26039300 :                         * saved_nregs / hard_regno_nregs (hard_regno,
    1921                 :            :                                                           mode) - 1);
    1922                 :   26039300 :             cost += add_cost;
    1923                 :   26039300 :             full_cost += add_cost;
    1924                 :            :           }
    1925                 :            :         }
    1926                 :  133621000 :       if (min_cost > cost)
    1927                 :            :         min_cost = cost;
    1928                 :  133621000 :       if (min_full_cost > full_cost)
    1929                 :            :         {
    1930                 :   18348100 :           min_full_cost = full_cost;
    1931                 :   18348100 :           best_hard_regno = hard_regno;
    1932                 :   18348100 :           ira_assert (hard_regno >= 0);
    1933                 :            :         }
    1934                 :  133621000 :       if (internal_flag_ira_verbose > 5 && ira_dump_file != NULL)
    1935                 :          0 :         fprintf (ira_dump_file, "(%d=%d,%d) ", hard_regno, cost, full_cost);
    1936                 :            :     }
    1937                 :   13628200 :   if (min_full_cost > mem_cost
    1938                 :            :       /* Do not spill static chain pointer pseudo when non-local goto
    1939                 :            :          is used.  */
    1940                 :   13628200 :       && ! non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a)))
    1941                 :            :     {
    1942                 :      19964 :       if (! retry_p && internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    1943                 :          0 :         fprintf (ira_dump_file, "(memory is more profitable %d vs %d) ",
    1944                 :            :                  mem_cost, min_full_cost);
    1945                 :            :       best_hard_regno = -1;
    1946                 :            :     }
    1947                 :   14650400 :  fail:
    1948                 :   14650400 :   if (best_hard_regno >= 0)
    1949                 :            :     {
    1950                 :   27423700 :       for (i = hard_regno_nregs (best_hard_regno, mode) - 1; i >= 0; i--)
    1951                 :   13815500 :         allocated_hardreg_p[best_hard_regno + i] = true;
    1952                 :            :     }
    1953                 :   14670400 :   if (! retry_p)
    1954                 :   14670400 :     restore_costs_from_copies (a);
    1955                 :   14670400 :   ALLOCNO_HARD_REGNO (a) = best_hard_regno;
    1956                 :   14670400 :   ALLOCNO_ASSIGNED_P (a) = true;
    1957                 :   14670400 :   if (best_hard_regno >= 0)
    1958                 :   13608200 :     update_costs_from_copies (a, true, ! retry_p);
    1959                 :   14670400 :   ira_assert (ALLOCNO_CLASS (a) == aclass);
    1960                 :            :   /* We don't need updated costs anymore.  */
    1961                 :   14670400 :   ira_free_allocno_updated_costs (a);
    1962                 :   14670400 :   return best_hard_regno >= 0;
    1963                 :            : }
    1964                 :            : 
    1965                 :            : 
    1966                 :            : 
    1967                 :            : /* An array used to sort copies.  */
    1968                 :            : static ira_copy_t *sorted_copies;
    1969                 :            : 
    1970                 :            : /* If allocno A is a cap, return non-cap allocno from which A is
    1971                 :            :    created.  Otherwise, return A.  */
    1972                 :            : static ira_allocno_t
    1973                 :          0 : get_cap_member (ira_allocno_t a)
    1974                 :            : {
    1975                 :   40256800 :   ira_allocno_t member;
    1976                 :            :   
    1977                 :   20175100 :   while ((member = ALLOCNO_CAP_MEMBER (a)) != NULL)
    1978                 :            :     a = member;
    1979                 :          0 :   return a;
    1980                 :            : }
    1981                 :            : 
    1982                 :            : /* Return TRUE if live ranges of allocnos A1 and A2 intersect.  It is
    1983                 :            :    used to find a conflict for new allocnos or allocnos with the
    1984                 :            :    different allocno classes.  */
    1985                 :            : static bool
    1986                 :   14119400 : allocnos_conflict_by_live_ranges_p (ira_allocno_t a1, ira_allocno_t a2)
    1987                 :            : {
    1988                 :   14119400 :   rtx reg1, reg2;
    1989                 :   14119400 :   int i, j;
    1990                 :   14119400 :   int n1 = ALLOCNO_NUM_OBJECTS (a1);
    1991                 :   14119400 :   int n2 = ALLOCNO_NUM_OBJECTS (a2);
    1992                 :            : 
    1993                 :   14119400 :   if (a1 == a2)
    1994                 :            :     return false;
    1995                 :   14119400 :   reg1 = regno_reg_rtx[ALLOCNO_REGNO (a1)];
    1996                 :   14119400 :   reg2 = regno_reg_rtx[ALLOCNO_REGNO (a2)];
    1997                 :   14119400 :   if (reg1 != NULL && reg2 != NULL
    1998                 :   14119400 :       && ORIGINAL_REGNO (reg1) == ORIGINAL_REGNO (reg2))
    1999                 :            :     return false;
    2000                 :            : 
    2001                 :            :   /* We don't keep live ranges for caps because they can be quite big.
    2002                 :            :      Use ranges of non-cap allocno from which caps are created.  */
    2003                 :   20081600 :   a1 = get_cap_member (a1);
    2004                 :   27535700 :   a2 = get_cap_member (a2);
    2005                 :   27535700 :   for (i = 0; i < n1; i++)
    2006                 :            :     {
    2007                 :   14168800 :       ira_object_t c1 = ALLOCNO_OBJECT (a1, i);
    2008                 :            : 
    2009                 :   27769600 :       for (j = 0; j < n2; j++)
    2010                 :            :         {
    2011                 :   14323500 :           ira_object_t c2 = ALLOCNO_OBJECT (a2, j);
    2012                 :            : 
    2013                 :   14323500 :           if (ira_live_ranges_intersect_p (OBJECT_LIVE_RANGES (c1),
    2014                 :            :                                            OBJECT_LIVE_RANGES (c2)))
    2015                 :            :             return true;
    2016                 :            :         }
    2017                 :            :     }
    2018                 :            :   return false;
    2019                 :            : }
    2020                 :            : 
    2021                 :            : /* The function is used to sort copies according to their execution
    2022                 :            :    frequencies.  */
    2023                 :            : static int
    2024                 :   78831600 : copy_freq_compare_func (const void *v1p, const void *v2p)
    2025                 :            : {
    2026                 :   78831600 :   ira_copy_t cp1 = *(const ira_copy_t *) v1p, cp2 = *(const ira_copy_t *) v2p;
    2027                 :   78831600 :   int pri1, pri2;
    2028                 :            : 
    2029                 :   78831600 :   pri1 = cp1->freq;
    2030                 :   78831600 :   pri2 = cp2->freq;
    2031                 :   78831600 :   if (pri2 - pri1)
    2032                 :   26868000 :     return pri2 - pri1;
    2033                 :            : 
    2034                 :            :   /* If frequencies are equal, sort by copies, so that the results of
    2035                 :            :      qsort leave nothing to chance.  */
    2036                 :   51963600 :   return cp1->num - cp2->num;
    2037                 :            : }
    2038                 :            : 
    2039                 :            : 
    2040                 :            : 
    2041                 :            : /* Return true if any allocno from thread of A1 conflicts with any
    2042                 :            :    allocno from thread A2.  */
    2043                 :            : static bool
    2044                 :    4795960 : allocno_thread_conflict_p (ira_allocno_t a1, ira_allocno_t a2)
    2045                 :            : {
    2046                 :    4795960 :   ira_allocno_t a, conflict_a;
    2047                 :            : 
    2048                 :    4795960 :   for (a = ALLOCNO_COLOR_DATA (a2)->next_thread_allocno;;
    2049                 :    4358460 :        a = ALLOCNO_COLOR_DATA (a)->next_thread_allocno)
    2050                 :            :     {
    2051                 :    9154410 :       for (conflict_a = ALLOCNO_COLOR_DATA (a1)->next_thread_allocno;;
    2052                 :    4964970 :            conflict_a = ALLOCNO_COLOR_DATA (conflict_a)->next_thread_allocno)
    2053                 :            :         {
    2054                 :   14119400 :           if (allocnos_conflict_by_live_ranges_p (a, conflict_a))
    2055                 :            :             return true;
    2056                 :   13396600 :           if (conflict_a == a1)
    2057                 :            :             break;
    2058                 :            :         }
    2059                 :    8431650 :       if (a == a2)
    2060                 :            :         break;
    2061                 :            :     }
    2062                 :            :   return false;
    2063                 :            : }
    2064                 :            : 
    2065                 :            : /* Merge two threads given correspondingly by their first allocnos T1
    2066                 :            :    and T2 (more accurately merging T2 into T1).  */
    2067                 :            : static void
    2068                 :    4073190 : merge_threads (ira_allocno_t t1, ira_allocno_t t2)
    2069                 :            : {
    2070                 :    4073190 :   ira_allocno_t a, next, last;
    2071                 :            : 
    2072                 :    4073190 :   gcc_assert (t1 != t2
    2073                 :            :               && ALLOCNO_COLOR_DATA (t1)->first_thread_allocno == t1
    2074                 :            :               && ALLOCNO_COLOR_DATA (t2)->first_thread_allocno == t2);
    2075                 :    4073190 :   for (last = t2, a = ALLOCNO_COLOR_DATA (t2)->next_thread_allocno;;
    2076                 :    4166360 :        a = ALLOCNO_COLOR_DATA (a)->next_thread_allocno)
    2077                 :            :     {
    2078                 :    8239550 :       ALLOCNO_COLOR_DATA (a)->first_thread_allocno = t1;
    2079                 :    8239550 :       if (a == t2)
    2080                 :            :         break;
    2081                 :    4166360 :       last = a;
    2082                 :            :     }
    2083                 :    4073190 :   next = ALLOCNO_COLOR_DATA (t1)->next_thread_allocno;
    2084                 :    4073190 :   ALLOCNO_COLOR_DATA (t1)->next_thread_allocno = t2;
    2085                 :    4073190 :   ALLOCNO_COLOR_DATA (last)->next_thread_allocno = next;
    2086                 :    4073190 :   ALLOCNO_COLOR_DATA (t1)->thread_freq += ALLOCNO_COLOR_DATA (t2)->thread_freq;
    2087                 :    4073190 : }
    2088                 :            : 
    2089                 :            : /* Create threads by processing CP_NUM copies from sorted copies.  We
    2090                 :            :    process the most expensive copies first.  */
    2091                 :            : static void
    2092                 :    5206960 : form_threads_from_copies (int cp_num)
    2093                 :            : {
    2094                 :    5206960 :   ira_allocno_t a, thread1, thread2;
    2095                 :    5206960 :   ira_copy_t cp;
    2096                 :    5206960 :   int i, n;
    2097                 :            : 
    2098                 :    5206960 :   qsort (sorted_copies, cp_num, sizeof (ira_copy_t), copy_freq_compare_func);
    2099                 :            :   /* Form threads processing copies, most frequently executed
    2100                 :            :      first.  */
    2101                 :    9845610 :   for (; cp_num != 0;)
    2102                 :            :     {
    2103                 :    5834370 :       for (i = 0; i < cp_num; i++)
    2104                 :            :         {
    2105                 :    5268920 :           cp = sorted_copies[i];
    2106                 :    5268920 :           thread1 = ALLOCNO_COLOR_DATA (cp->first)->first_thread_allocno;
    2107                 :    5268920 :           thread2 = ALLOCNO_COLOR_DATA (cp->second)->first_thread_allocno;
    2108                 :    5268920 :           if (thread1 == thread2)
    2109                 :     472965 :             continue;
    2110                 :    4795960 :           if (! allocno_thread_conflict_p (thread1, thread2))
    2111                 :            :             {
    2112                 :    4073190 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2113                 :        225 :                 fprintf
    2114                 :        225 :                   (ira_dump_file,
    2115                 :            :                    "      Forming thread by copy %d:a%dr%d-a%dr%d (freq=%d):\n",
    2116                 :        225 :                    cp->num, ALLOCNO_NUM (cp->first), ALLOCNO_REGNO (cp->first),
    2117                 :        225 :                    ALLOCNO_NUM (cp->second), ALLOCNO_REGNO (cp->second),
    2118                 :            :                    cp->freq);
    2119                 :    4073190 :               merge_threads (thread1, thread2);
    2120                 :    4073190 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2121                 :            :                 {
    2122                 :        225 :                   thread1 = ALLOCNO_COLOR_DATA (thread1)->first_thread_allocno;
    2123                 :        225 :                   fprintf (ira_dump_file, "        Result (freq=%d): a%dr%d(%d)",
    2124                 :        225 :                            ALLOCNO_COLOR_DATA (thread1)->thread_freq,
    2125                 :            :                            ALLOCNO_NUM (thread1), ALLOCNO_REGNO (thread1),
    2126                 :            :                            ALLOCNO_FREQ (thread1));
    2127                 :        225 :                   for (a = ALLOCNO_COLOR_DATA (thread1)->next_thread_allocno;
    2128                 :        525 :                        a != thread1;
    2129                 :        300 :                        a = ALLOCNO_COLOR_DATA (a)->next_thread_allocno)
    2130                 :        300 :                     fprintf (ira_dump_file, " a%dr%d(%d)",
    2131                 :            :                              ALLOCNO_NUM (a), ALLOCNO_REGNO (a),
    2132                 :            :                              ALLOCNO_FREQ (a));
    2133                 :        225 :                   fprintf (ira_dump_file, "\n");
    2134                 :            :                 }
    2135                 :    4073190 :               i++;
    2136                 :    4073190 :               break;
    2137                 :            :             }
    2138                 :            :         }
    2139                 :            :       /* Collect the rest of copies.  */
    2140                 :  227175000 :       for (n = 0; i < cp_num; i++)
    2141                 :            :         {
    2142                 :  222536000 :           cp = sorted_copies[i];
    2143                 :  222536000 :           if (ALLOCNO_COLOR_DATA (cp->first)->first_thread_allocno
    2144                 :  222536000 :               != ALLOCNO_COLOR_DATA (cp->second)->first_thread_allocno)
    2145                 :  222350000 :             sorted_copies[n++] = cp;
    2146                 :            :         }
    2147                 :            :       cp_num = n;
    2148                 :            :     }
    2149                 :    5206960 : }
    2150                 :            : 
    2151                 :            : /* Create threads by processing copies of all alocnos from BUCKET.  We
    2152                 :            :    process the most expensive copies first.  */
    2153                 :            : static void
    2154                 :    1981420 : form_threads_from_bucket (ira_allocno_t bucket)
    2155                 :            : {
    2156                 :    1981420 :   ira_allocno_t a;
    2157                 :    1981420 :   ira_copy_t cp, next_cp;
    2158                 :    1981420 :   int cp_num = 0;
    2159                 :            : 
    2160                 :   13546300 :   for (a = bucket; a != NULL; a = ALLOCNO_COLOR_DATA (a)->next_bucket_allocno)
    2161                 :            :     {
    2162                 :   19760900 :       for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    2163                 :            :         {
    2164                 :    8196000 :           if (cp->first == a)
    2165                 :            :             {
    2166                 :    3937620 :               next_cp = cp->next_first_allocno_copy;
    2167                 :    3937620 :               sorted_copies[cp_num++] = cp;
    2168                 :            :             }
    2169                 :    4258380 :           else if (cp->second == a)
    2170                 :    4258380 :             next_cp = cp->next_second_allocno_copy;
    2171                 :            :           else
    2172                 :          0 :             gcc_unreachable ();
    2173                 :            :         }
    2174                 :            :     }
    2175                 :    1981420 :   form_threads_from_copies (cp_num);
    2176                 :    1981420 : }
    2177                 :            : 
    2178                 :            : /* Create threads by processing copies of colorable allocno A.  We
    2179                 :            :    process most expensive copies first.  */
    2180                 :            : static void
    2181                 :    3225540 : form_threads_from_colorable_allocno (ira_allocno_t a)
    2182                 :            : {
    2183                 :    3225540 :   ira_allocno_t another_a;
    2184                 :    3225540 :   ira_copy_t cp, next_cp;
    2185                 :    3225540 :   int cp_num = 0;
    2186                 :            : 
    2187                 :    5561480 :   for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    2188                 :            :     {
    2189                 :    2335940 :       if (cp->first == a)
    2190                 :            :         {
    2191                 :    1441310 :           next_cp = cp->next_first_allocno_copy;
    2192                 :    1441310 :           another_a = cp->second;
    2193                 :            :         }
    2194                 :     894636 :       else if (cp->second == a)
    2195                 :            :         {
    2196                 :     894636 :           next_cp = cp->next_second_allocno_copy;
    2197                 :     894636 :           another_a = cp->first;
    2198                 :            :         }
    2199                 :            :       else
    2200                 :          0 :         gcc_unreachable ();
    2201                 :    2335940 :       if ((! ALLOCNO_COLOR_DATA (another_a)->in_graph_p
    2202                 :    2335940 :            && !ALLOCNO_COLOR_DATA (another_a)->may_be_spilled_p)
    2203                 :    1265380 :            || ALLOCNO_COLOR_DATA (another_a)->colorable_p)
    2204                 :    1518090 :         sorted_copies[cp_num++] = cp;
    2205                 :            :     }
    2206                 :    3225540 :   form_threads_from_copies (cp_num);
    2207                 :    3225540 : }
    2208                 :            : 
    2209                 :            : /* Form initial threads which contain only one allocno.  */
    2210                 :            : static void
    2211                 :     792991 : init_allocno_threads (void)
    2212                 :            : {
    2213                 :     792991 :   ira_allocno_t a;
    2214                 :     792991 :   unsigned int j;
    2215                 :     792991 :   bitmap_iterator bi;
    2216                 :     792991 :   ira_pref_t pref;
    2217                 :            : 
    2218                 :   17747400 :   EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, j, bi)
    2219                 :            :     {
    2220                 :   16954400 :       a = ira_allocnos[j];
    2221                 :            :       /* Set up initial thread data: */
    2222                 :   16954400 :       ALLOCNO_COLOR_DATA (a)->first_thread_allocno
    2223                 :   16954400 :         = ALLOCNO_COLOR_DATA (a)->next_thread_allocno = a;
    2224                 :   16954400 :       ALLOCNO_COLOR_DATA (a)->thread_freq = ALLOCNO_FREQ (a);
    2225                 :   16954400 :       ALLOCNO_COLOR_DATA (a)->hard_reg_prefs = 0;
    2226                 :   20773500 :       for (pref = ALLOCNO_PREFS (a); pref != NULL; pref = pref->next_pref)
    2227                 :    3819150 :         ALLOCNO_COLOR_DATA (a)->hard_reg_prefs += pref->freq;
    2228                 :            :     }
    2229                 :     792991 : }
    2230                 :            : 
    2231                 :            : 
    2232                 :            : 
    2233                 :            : /* This page contains the allocator based on the Chaitin-Briggs algorithm.  */
    2234                 :            : 
    2235                 :            : /* Bucket of allocnos that can colored currently without spilling.  */
    2236                 :            : static ira_allocno_t colorable_allocno_bucket;
    2237                 :            : 
    2238                 :            : /* Bucket of allocnos that might be not colored currently without
    2239                 :            :    spilling.  */
    2240                 :            : static ira_allocno_t uncolorable_allocno_bucket;
    2241                 :            : 
    2242                 :            : /* The current number of allocnos in the uncolorable_bucket.  */
    2243                 :            : static int uncolorable_allocnos_num;
    2244                 :            : 
    2245                 :            : /* Return the current spill priority of allocno A.  The less the
    2246                 :            :    number, the more preferable the allocno for spilling.  */
    2247                 :            : static inline int
    2248                 :  129564000 : allocno_spill_priority (ira_allocno_t a)
    2249                 :            : {
    2250                 :  129564000 :   allocno_color_data_t data = ALLOCNO_COLOR_DATA (a);
    2251                 :            : 
    2252                 :  129564000 :   return (data->temp
    2253                 :  129564000 :           / (ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a)
    2254                 :  129564000 :              * ira_reg_class_max_nregs[ALLOCNO_CLASS (a)][ALLOCNO_MODE (a)]
    2255                 :  129564000 :              + 1));
    2256                 :            : }
    2257                 :            : 
    2258                 :            : /* Add allocno A to bucket *BUCKET_PTR.  A should be not in a bucket
    2259                 :            :    before the call.  */
    2260                 :            : static void
    2261                 :   14476100 : add_allocno_to_bucket (ira_allocno_t a, ira_allocno_t *bucket_ptr)
    2262                 :            : {
    2263                 :   14476100 :   ira_allocno_t first_a;
    2264                 :   14476100 :   allocno_color_data_t data;
    2265                 :            : 
    2266                 :    4414000 :   if (bucket_ptr == &uncolorable_allocno_bucket
    2267                 :    4414000 :       && ALLOCNO_CLASS (a) != NO_REGS)
    2268                 :            :     {
    2269                 :    4414000 :       uncolorable_allocnos_num++;
    2270                 :    4414000 :       ira_assert (uncolorable_allocnos_num > 0);
    2271                 :            :     }
    2272                 :   14476100 :   first_a = *bucket_ptr;
    2273                 :   14476100 :   data = ALLOCNO_COLOR_DATA (a);
    2274                 :   14476100 :   data->next_bucket_allocno = first_a;
    2275                 :   14476100 :   data->prev_bucket_allocno = NULL;
    2276                 :    4414000 :   if (first_a != NULL)
    2277                 :   13564500 :     ALLOCNO_COLOR_DATA (first_a)->prev_bucket_allocno = a;
    2278                 :   14476100 :   *bucket_ptr = a;
    2279                 :   10062100 : }
    2280                 :            : 
    2281                 :            : /* Compare two allocnos to define which allocno should be pushed first
    2282                 :            :    into the coloring stack.  If the return is a negative number, the
    2283                 :            :    allocno given by the first parameter will be pushed first.  In this
    2284                 :            :    case such allocno has less priority than the second one and the
    2285                 :            :    hard register will be assigned to it after assignment to the second
    2286                 :            :    one.  As the result of such assignment order, the second allocno
    2287                 :            :    has a better chance to get the best hard register.  */
    2288                 :            : static int
    2289                 :  320522000 : bucket_allocno_compare_func (const void *v1p, const void *v2p)
    2290                 :            : {
    2291                 :  320522000 :   ira_allocno_t a1 = *(const ira_allocno_t *) v1p;
    2292                 :  320522000 :   ira_allocno_t a2 = *(const ira_allocno_t *) v2p;
    2293                 :  320522000 :   int diff, freq1, freq2, a1_num, a2_num, pref1, pref2;
    2294                 :  320522000 :   ira_allocno_t t1 = ALLOCNO_COLOR_DATA (a1)->first_thread_allocno;
    2295                 :  320522000 :   ira_allocno_t t2 = ALLOCNO_COLOR_DATA (a2)->first_thread_allocno;
    2296                 :  320522000 :   int cl1 = ALLOCNO_CLASS (a1), cl2 = ALLOCNO_CLASS (a2);
    2297                 :            : 
    2298                 :  320522000 :   freq1 = ALLOCNO_COLOR_DATA (t1)->thread_freq;
    2299                 :  320522000 :   freq2 = ALLOCNO_COLOR_DATA (t2)->thread_freq;
    2300                 :  320522000 :   if ((diff = freq1 - freq2) != 0)
    2301                 :            :     return diff;
    2302                 :            :   
    2303                 :  121463000 :   if ((diff = ALLOCNO_NUM (t2) - ALLOCNO_NUM (t1)) != 0)
    2304                 :            :     return diff;
    2305                 :            : 
    2306                 :            :   /* Push pseudos requiring less hard registers first.  It means that
    2307                 :            :      we will assign pseudos requiring more hard registers first
    2308                 :            :      avoiding creation small holes in free hard register file into
    2309                 :            :      which the pseudos requiring more hard registers cannot fit.  */
    2310                 :   16343100 :   if ((diff = (ira_reg_class_max_nregs[cl1][ALLOCNO_MODE (a1)]
    2311                 :   16343100 :                - ira_reg_class_max_nregs[cl2][ALLOCNO_MODE (a2)])) != 0)
    2312                 :            :     return diff;
    2313                 :            : 
    2314                 :   16277400 :   freq1 = ALLOCNO_FREQ (a1);
    2315                 :   16277400 :   freq2 = ALLOCNO_FREQ (a2);
    2316                 :   16277400 :   if ((diff = freq1 - freq2) != 0)
    2317                 :            :     return diff;
    2318                 :            : 
    2319                 :    8931000 :   a1_num = ALLOCNO_COLOR_DATA (a1)->available_regs_num;
    2320                 :    8931000 :   a2_num = ALLOCNO_COLOR_DATA (a2)->available_regs_num;
    2321                 :    8931000 :   if ((diff = a2_num - a1_num) != 0)
    2322                 :            :     return diff;
    2323                 :            :   /* Push allocnos with minimal conflict_allocno_hard_prefs first.  */
    2324                 :    7019170 :   pref1 = ALLOCNO_COLOR_DATA (a1)->conflict_allocno_hard_prefs;
    2325                 :    7019170 :   pref2 = ALLOCNO_COLOR_DATA (a2)->conflict_allocno_hard_prefs;
    2326                 :    7019170 :   if ((diff = pref1 - pref2) != 0)
    2327                 :            :     return diff;
    2328                 :    6665540 :   return ALLOCNO_NUM (a2) - ALLOCNO_NUM (a1);
    2329                 :            : }
    2330                 :            : 
    2331                 :            : /* Sort bucket *BUCKET_PTR and return the result through
    2332                 :            :    BUCKET_PTR.  */
    2333                 :            : static void
    2334                 :    2774390 : sort_bucket (ira_allocno_t *bucket_ptr,
    2335                 :            :              int (*compare_func) (const void *, const void *))
    2336                 :            : {
    2337                 :    2774390 :   ira_allocno_t a, head;
    2338                 :    2774390 :   int n;
    2339                 :            : 
    2340                 :    2774390 :   for (n = 0, a = *bucket_ptr;
    2341                 :   18753300 :        a != NULL;
    2342                 :   15978900 :        a = ALLOCNO_COLOR_DATA (a)->next_bucket_allocno)
    2343                 :   15978900 :     sorted_allocnos[n++] = a;
    2344                 :    2774390 :   if (n <= 1)
    2345                 :            :     return;
    2346                 :    1092390 :   qsort (sorted_allocnos, n, sizeof (ira_allocno_t), compare_func);
    2347                 :    1092390 :   head = NULL;
    2348                 :   16929100 :   for (n--; n >= 0; n--)
    2349                 :            :     {
    2350                 :   15836700 :       a = sorted_allocnos[n];
    2351                 :   15836700 :       ALLOCNO_COLOR_DATA (a)->next_bucket_allocno = head;
    2352                 :   15836700 :       ALLOCNO_COLOR_DATA (a)->prev_bucket_allocno = NULL;
    2353                 :   15836700 :       if (head != NULL)
    2354                 :   14744300 :         ALLOCNO_COLOR_DATA (head)->prev_bucket_allocno = a;
    2355                 :   15836700 :       head = a;
    2356                 :            :     }
    2357                 :    1092390 :   *bucket_ptr = head;
    2358                 :            : }
    2359                 :            : 
    2360                 :            : /* Add ALLOCNO to colorable bucket maintaining the order according
    2361                 :            :    their priority.  ALLOCNO should be not in a bucket before the
    2362                 :            :    call.  */
    2363                 :            : static void
    2364                 :    3225540 : add_allocno_to_ordered_colorable_bucket (ira_allocno_t allocno)
    2365                 :            : {
    2366                 :    3225540 :   ira_allocno_t before, after;
    2367                 :            : 
    2368                 :    3225540 :   form_threads_from_colorable_allocno (allocno);
    2369                 :    3225540 :   for (before = colorable_allocno_bucket, after = NULL;
    2370                 :   25983700 :        before != NULL;
    2371                 :   22758200 :        after = before,
    2372                 :   22758200 :          before = ALLOCNO_COLOR_DATA (before)->next_bucket_allocno)
    2373                 :   25159000 :     if (bucket_allocno_compare_func (&allocno, &before) < 0)
    2374                 :            :       break;
    2375                 :    3225540 :   ALLOCNO_COLOR_DATA (allocno)->next_bucket_allocno = before;
    2376                 :    3225540 :   ALLOCNO_COLOR_DATA (allocno)->prev_bucket_allocno = after;
    2377                 :    3225540 :   if (after == NULL)
    2378                 :    1601870 :     colorable_allocno_bucket = allocno;
    2379                 :            :   else
    2380                 :    1623670 :     ALLOCNO_COLOR_DATA (after)->next_bucket_allocno = allocno;
    2381                 :    3225540 :   if (before != NULL)
    2382                 :    2400780 :     ALLOCNO_COLOR_DATA (before)->prev_bucket_allocno = allocno;
    2383                 :    3225540 : }
    2384                 :            : 
    2385                 :            : /* Delete ALLOCNO from bucket *BUCKET_PTR.  It should be there before
    2386                 :            :    the call.  */
    2387                 :            : static void
    2388                 :   17701700 : delete_allocno_from_bucket (ira_allocno_t allocno, ira_allocno_t *bucket_ptr)
    2389                 :            : {
    2390                 :   17701700 :   ira_allocno_t prev_allocno, next_allocno;
    2391                 :            : 
    2392                 :   17701700 :   if (bucket_ptr == &uncolorable_allocno_bucket
    2393                 :    4414000 :       && ALLOCNO_CLASS (allocno) != NO_REGS)
    2394                 :            :     {
    2395                 :    4414000 :       uncolorable_allocnos_num--;
    2396                 :    4414000 :       ira_assert (uncolorable_allocnos_num >= 0);
    2397                 :            :     }
    2398                 :   17701700 :   prev_allocno = ALLOCNO_COLOR_DATA (allocno)->prev_bucket_allocno;
    2399                 :   17701700 :   next_allocno = ALLOCNO_COLOR_DATA (allocno)->next_bucket_allocno;
    2400                 :   17701700 :   if (prev_allocno != NULL)
    2401                 :    2555950 :     ALLOCNO_COLOR_DATA (prev_allocno)->next_bucket_allocno = next_allocno;
    2402                 :            :   else
    2403                 :            :     {
    2404                 :   15145700 :       ira_assert (*bucket_ptr == allocno);
    2405                 :   15145700 :       *bucket_ptr = next_allocno;
    2406                 :            :     }
    2407                 :   17701700 :   if (next_allocno != NULL)
    2408                 :   15996200 :     ALLOCNO_COLOR_DATA (next_allocno)->prev_bucket_allocno = prev_allocno;
    2409                 :   17701700 : }
    2410                 :            : 
    2411                 :            : /* Put allocno A onto the coloring stack without removing it from its
    2412                 :            :    bucket.  Pushing allocno to the coloring stack can result in moving
    2413                 :            :    conflicting allocnos from the uncolorable bucket to the colorable
    2414                 :            :    one.  Update conflict_allocno_hard_prefs of the conflicting
    2415                 :            :    allocnos which are not on stack yet.  */
    2416                 :            : static void
    2417                 :   14476100 : push_allocno_to_stack (ira_allocno_t a)
    2418                 :            : {
    2419                 :   14476100 :   enum reg_class aclass;
    2420                 :   14476100 :   allocno_color_data_t data, conflict_data;
    2421                 :   14476100 :   int size, i, n = ALLOCNO_NUM_OBJECTS (a);
    2422                 :            :     
    2423                 :   14476100 :   data = ALLOCNO_COLOR_DATA (a);
    2424                 :   14476100 :   data->in_graph_p = false;
    2425                 :   14476100 :   allocno_stack_vec.safe_push (a);
    2426                 :   14476100 :   aclass = ALLOCNO_CLASS (a);
    2427                 :   14476100 :   if (aclass == NO_REGS)
    2428                 :            :     return;
    2429                 :   14476100 :   size = ira_reg_class_max_nregs[aclass][ALLOCNO_MODE (a)];
    2430                 :   14476100 :   if (n > 1)
    2431                 :            :     {
    2432                 :            :       /* We will deal with the subwords individually.  */
    2433                 :     259749 :       gcc_assert (size == ALLOCNO_NUM_OBJECTS (a));
    2434                 :            :       size = 1;
    2435                 :            :     }
    2436                 :   29212000 :   for (i = 0; i < n; i++)
    2437                 :            :     {
    2438                 :   14735900 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2439                 :   14735900 :       ira_object_t conflict_obj;
    2440                 :   14735900 :       ira_object_conflict_iterator oci;
    2441                 :            :       
    2442                 :  398606000 :       FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    2443                 :            :         {
    2444                 :  383870000 :           ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    2445                 :  383870000 :           ira_pref_t pref;
    2446                 :            : 
    2447                 :  383870000 :           conflict_data = ALLOCNO_COLOR_DATA (conflict_a);
    2448                 :  602807000 :           if (! conflict_data->in_graph_p
    2449                 :  165462000 :               || ALLOCNO_ASSIGNED_P (conflict_a)
    2450                 :  383870000 :               || !(hard_reg_set_intersect_p
    2451                 :  165462000 :                    (ALLOCNO_COLOR_DATA (a)->profitable_hard_regs,
    2452                 :  165462000 :                     conflict_data->profitable_hard_regs)))
    2453                 :  218937000 :             continue;
    2454                 :  180190000 :           for (pref = ALLOCNO_PREFS (a); pref != NULL; pref = pref->next_pref)
    2455                 :   15257200 :             conflict_data->conflict_allocno_hard_prefs -= pref->freq;
    2456                 :  164933000 :           if (conflict_data->colorable_p)
    2457                 :   17136500 :             continue;
    2458                 :  147796000 :           ira_assert (bitmap_bit_p (coloring_allocno_bitmap,
    2459                 :            :                                     ALLOCNO_NUM (conflict_a)));
    2460                 :  147796000 :           if (update_left_conflict_sizes_p (conflict_a, a, size))
    2461                 :            :             {
    2462                 :    3225540 :               delete_allocno_from_bucket
    2463                 :    3225540 :                 (conflict_a, &uncolorable_allocno_bucket);
    2464                 :    3225540 :               add_allocno_to_ordered_colorable_bucket (conflict_a);
    2465                 :    3225540 :               if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL)
    2466                 :            :                 {
    2467                 :         68 :                   fprintf (ira_dump_file, "        Making");
    2468                 :         68 :                   ira_print_expanded_allocno (conflict_a);
    2469                 :         68 :                   fprintf (ira_dump_file, " colorable\n");
    2470                 :            :                 }
    2471                 :            :             }
    2472                 :            :           
    2473                 :            :         }
    2474                 :            :     }
    2475                 :            : }
    2476                 :            : 
    2477                 :            : /* Put ALLOCNO onto the coloring stack and remove it from its bucket.
    2478                 :            :    The allocno is in the colorable bucket if COLORABLE_P is TRUE.  */
    2479                 :            : static void
    2480                 :   14476100 : remove_allocno_from_bucket_and_push (ira_allocno_t allocno, bool colorable_p)
    2481                 :            : {
    2482                 :   14476100 :   if (colorable_p)
    2483                 :   13287700 :     delete_allocno_from_bucket (allocno, &colorable_allocno_bucket);
    2484                 :            :   else
    2485                 :    1188460 :     delete_allocno_from_bucket (allocno, &uncolorable_allocno_bucket);
    2486                 :   14476100 :   if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2487                 :            :     {
    2488                 :        498 :       fprintf (ira_dump_file, "      Pushing");
    2489                 :        498 :       ira_print_expanded_allocno (allocno);
    2490                 :        498 :       if (colorable_p)
    2491                 :        498 :         fprintf (ira_dump_file, "(cost %d)\n",
    2492                 :        498 :                  ALLOCNO_COLOR_DATA (allocno)->temp);
    2493                 :            :       else
    2494                 :          0 :         fprintf (ira_dump_file, "(potential spill: %spri=%d, cost=%d)\n",
    2495                 :          0 :                  ALLOCNO_BAD_SPILL_P (allocno) ? "bad spill, " : "",
    2496                 :            :                  allocno_spill_priority (allocno),
    2497                 :          0 :                  ALLOCNO_COLOR_DATA (allocno)->temp);
    2498                 :            :     }
    2499                 :   14476100 :   if (! colorable_p)
    2500                 :    1188460 :     ALLOCNO_COLOR_DATA (allocno)->may_be_spilled_p = true;
    2501                 :   14476100 :   push_allocno_to_stack (allocno);
    2502                 :   14476100 : }
    2503                 :            : 
    2504                 :            : /* Put all allocnos from colorable bucket onto the coloring stack.  */
    2505                 :            : static void
    2506                 :    1981420 : push_only_colorable (void)
    2507                 :            : {
    2508                 :    1981420 :   form_threads_from_bucket (colorable_allocno_bucket);
    2509                 :    1981420 :   sort_bucket (&colorable_allocno_bucket, bucket_allocno_compare_func);
    2510                 :   15269100 :   for (;colorable_allocno_bucket != NULL;)
    2511                 :   13287700 :     remove_allocno_from_bucket_and_push (colorable_allocno_bucket, true);
    2512                 :    1981420 : }
    2513                 :            : 
    2514                 :            : /* Return the frequency of exit edges (if EXIT_P) or entry from/to the
    2515                 :            :    loop given by its LOOP_NODE.  */
    2516                 :            : int
    2517                 :    7779900 : ira_loop_edge_freq (ira_loop_tree_node_t loop_node, int regno, bool exit_p)
    2518                 :            : {
    2519                 :    7779900 :   int freq, i;
    2520                 :    7779900 :   edge_iterator ei;
    2521                 :    7779900 :   edge e;
    2522                 :    7779900 :   vec<edge> edges;
    2523                 :            : 
    2524                 :    7779900 :   ira_assert (current_loops != NULL && loop_node->loop != NULL
    2525                 :            :               && (regno < 0 || regno >= FIRST_PSEUDO_REGISTER));
    2526                 :    7779900 :   freq = 0;
    2527                 :    7779900 :   if (! exit_p)
    2528                 :            :     {
    2529                 :   12293200 :       FOR_EACH_EDGE (e, ei, loop_node->loop->header->preds)
    2530                 :    8403220 :         if (e->src != loop_node->loop->latch
    2531                 :    8403220 :             && (regno < 0
    2532                 :    4650880 :                 || (bitmap_bit_p (df_get_live_out (e->src), regno)
    2533                 :    4442810 :                     && bitmap_bit_p (df_get_live_in (e->dest), regno))))
    2534                 :    4436400 :           freq += EDGE_FREQUENCY (e);
    2535                 :            :     }
    2536                 :            :   else
    2537                 :            :     {
    2538                 :    3889950 :       edges = get_loop_exit_edges (loop_node->loop);
    2539                 :   18392700 :       FOR_EACH_VEC_ELT (edges, i, e)
    2540                 :   10613000 :         if (regno < 0
    2541                 :   10613000 :             || (bitmap_bit_p (df_get_live_out (e->src), regno)
    2542                 :    8000890 :                 && bitmap_bit_p (df_get_live_in (e->dest), regno)))
    2543                 :    3739710 :           freq += EDGE_FREQUENCY (e);
    2544                 :    3889950 :       edges.release ();
    2545                 :            :     }
    2546                 :            : 
    2547                 :    7779900 :   return REG_FREQ_FROM_EDGE_FREQ (freq);
    2548                 :            : }
    2549                 :            : 
    2550                 :            : /* Calculate and return the cost of putting allocno A into memory.  */
    2551                 :            : static int
    2552                 :    4414000 : calculate_allocno_spill_cost (ira_allocno_t a)
    2553                 :            : {
    2554                 :    4414000 :   int regno, cost;
    2555                 :    4414000 :   machine_mode mode;
    2556                 :    4414000 :   enum reg_class rclass;
    2557                 :    4414000 :   ira_allocno_t parent_allocno;
    2558                 :    4414000 :   ira_loop_tree_node_t parent_node, loop_node;
    2559                 :            : 
    2560                 :    4414000 :   regno = ALLOCNO_REGNO (a);
    2561                 :    4414000 :   cost = ALLOCNO_UPDATED_MEMORY_COST (a) - ALLOCNO_UPDATED_CLASS_COST (a);
    2562                 :    4414000 :   if (ALLOCNO_CAP (a) != NULL)
    2563                 :            :     return cost;
    2564                 :    3036340 :   loop_node = ALLOCNO_LOOP_TREE_NODE (a);
    2565                 :    3036340 :   if ((parent_node = loop_node->parent) == NULL)
    2566                 :            :     return cost;
    2567                 :     613179 :   if ((parent_allocno = parent_node->regno_allocno_map[regno]) == NULL)
    2568                 :            :     return cost;
    2569                 :     613179 :   mode = ALLOCNO_MODE (a);
    2570                 :     613179 :   rclass = ALLOCNO_CLASS (a);
    2571                 :     613179 :   if (ALLOCNO_HARD_REGNO (parent_allocno) < 0)
    2572                 :     501566 :     cost -= (ira_memory_move_cost[mode][rclass][0]
    2573                 :     250783 :              * ira_loop_edge_freq (loop_node, regno, true)
    2574                 :     501566 :              + ira_memory_move_cost[mode][rclass][1]
    2575                 :     250783 :              * ira_loop_edge_freq (loop_node, regno, false));
    2576                 :            :   else
    2577                 :            :     {
    2578                 :     362396 :       ira_init_register_move_cost_if_necessary (mode);
    2579                 :     724792 :       cost += ((ira_memory_move_cost[mode][rclass][1]
    2580                 :     362396 :                 * ira_loop_edge_freq (loop_node, regno, true)
    2581                 :     724792 :                 + ira_memory_move_cost[mode][rclass][0]
    2582                 :     362396 :                 * ira_loop_edge_freq (loop_node, regno, false))
    2583                 :     724792 :                - (ira_register_move_cost[mode][rclass][rclass]
    2584                 :     362396 :                   * (ira_loop_edge_freq (loop_node, regno, false)
    2585                 :     362396 :                      + ira_loop_edge_freq (loop_node, regno, true))));
    2586                 :            :     }
    2587                 :            :   return cost;
    2588                 :            : }
    2589                 :            : 
    2590                 :            : /* Used for sorting allocnos for spilling.  */
    2591                 :            : static inline int
    2592                 :  138312000 : allocno_spill_priority_compare (ira_allocno_t a1, ira_allocno_t a2)
    2593                 :            : {
    2594                 :  138312000 :   int pri1, pri2, diff;
    2595                 :            : 
    2596                 :            :   /* Avoid spilling static chain pointer pseudo when non-local goto is
    2597                 :            :      used.  */
    2598                 :  138312000 :   if (non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a1)))
    2599                 :            :     return 1;
    2600                 :  138312000 :   else if (non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a2)))
    2601                 :            :     return -1;
    2602                 :  138312000 :   if (ALLOCNO_BAD_SPILL_P (a1) && ! ALLOCNO_BAD_SPILL_P (a2))
    2603                 :            :     return 1;
    2604                 :  134025000 :   if (ALLOCNO_BAD_SPILL_P (a2) && ! ALLOCNO_BAD_SPILL_P (a1))
    2605                 :            :     return -1;
    2606                 :  129564000 :   pri1 = allocno_spill_priority (a1);
    2607                 :  129564000 :   pri2 = allocno_spill_priority (a2);
    2608                 :  129564000 :   if ((diff = pri1 - pri2) != 0)
    2609                 :            :     return diff;
    2610                 :   37005300 :   if ((diff
    2611                 :   37005300 :        = ALLOCNO_COLOR_DATA (a1)->temp - ALLOCNO_COLOR_DATA (a2)->temp) != 0)
    2612                 :            :     return diff;
    2613                 :   27902500 :   return ALLOCNO_NUM (a1) - ALLOCNO_NUM (a2);
    2614                 :            : }
    2615                 :            : 
    2616                 :            : /* Used for sorting allocnos for spilling.  */
    2617                 :            : static int
    2618                 :  138312000 : allocno_spill_sort_compare (const void *v1p, const void *v2p)
    2619                 :            : {
    2620                 :  138312000 :   ira_allocno_t p1 = *(const ira_allocno_t *) v1p;
    2621                 :  138312000 :   ira_allocno_t p2 = *(const ira_allocno_t *) v2p;
    2622                 :            : 
    2623                 :  138312000 :   return allocno_spill_priority_compare (p1, p2);
    2624                 :            : }
    2625                 :            : 
    2626                 :            : /* Push allocnos to the coloring stack.  The order of allocnos in the
    2627                 :            :    stack defines the order for the subsequent coloring.  */
    2628                 :            : static void
    2629                 :     792963 : push_allocnos_to_stack (void)
    2630                 :            : {
    2631                 :     792963 :   ira_allocno_t a;
    2632                 :     792963 :   int cost;
    2633                 :            : 
    2634                 :            :   /* Calculate uncolorable allocno spill costs.  */
    2635                 :     792963 :   for (a = uncolorable_allocno_bucket;
    2636                 :    5206960 :        a != NULL;
    2637                 :    4414000 :        a = ALLOCNO_COLOR_DATA (a)->next_bucket_allocno)
    2638                 :    4414000 :     if (ALLOCNO_CLASS (a) != NO_REGS)
    2639                 :            :       {
    2640                 :    4414000 :         cost = calculate_allocno_spill_cost (a);
    2641                 :            :         /* ??? Remove cost of copies between the coalesced
    2642                 :            :            allocnos.  */
    2643                 :    4414000 :         ALLOCNO_COLOR_DATA (a)->temp = cost;
    2644                 :            :       }
    2645                 :     792963 :   sort_bucket (&uncolorable_allocno_bucket, allocno_spill_sort_compare);
    2646                 :    3169890 :   for (;;)
    2647                 :            :     {
    2648                 :    1981420 :       push_only_colorable ();
    2649                 :    1981420 :       a = uncolorable_allocno_bucket;
    2650                 :    1981420 :       if (a == NULL)
    2651                 :            :         break;
    2652                 :    1188460 :       remove_allocno_from_bucket_and_push (a, false);
    2653                 :            :     }
    2654                 :     792963 :   ira_assert (colorable_allocno_bucket == NULL
    2655                 :            :               && uncolorable_allocno_bucket == NULL);
    2656                 :     792963 :   ira_assert (uncolorable_allocnos_num == 0);
    2657                 :     792963 : }
    2658                 :            : 
    2659                 :            : /* Pop the coloring stack and assign hard registers to the popped
    2660                 :            :    allocnos.  */
    2661                 :            : static void
    2662                 :     792963 : pop_allocnos_from_stack (void)
    2663                 :            : {
    2664                 :   15269100 :   ira_allocno_t allocno;
    2665                 :   15269100 :   enum reg_class aclass;
    2666                 :            : 
    2667                 :   15269100 :   for (;allocno_stack_vec.length () != 0;)
    2668                 :            :     {
    2669                 :   14476100 :       allocno = allocno_stack_vec.pop ();
    2670                 :   14476100 :       aclass = ALLOCNO_CLASS (allocno);
    2671                 :   14476100 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2672                 :            :         {
    2673                 :        498 :           fprintf (ira_dump_file, "      Popping");
    2674                 :        498 :           ira_print_expanded_allocno (allocno);
    2675                 :        498 :           fprintf (ira_dump_file, "  -- ");
    2676                 :            :         }
    2677                 :   14476100 :       if (aclass == NO_REGS)
    2678                 :            :         {
    2679                 :          0 :           ALLOCNO_HARD_REGNO (allocno) = -1;
    2680                 :          0 :           ALLOCNO_ASSIGNED_P (allocno) = true;
    2681                 :          0 :           ira_assert (ALLOCNO_UPDATED_HARD_REG_COSTS (allocno) == NULL);
    2682                 :          0 :           ira_assert
    2683                 :            :             (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (allocno) == NULL);
    2684                 :          0 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2685                 :          0 :             fprintf (ira_dump_file, "assign memory\n");
    2686                 :            :         }
    2687                 :   14476100 :       else if (assign_hard_reg (allocno, false))
    2688                 :            :         {
    2689                 :   13566000 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2690                 :        498 :             fprintf (ira_dump_file, "assign reg %d\n",
    2691                 :        498 :                      ALLOCNO_HARD_REGNO (allocno));
    2692                 :            :         }
    2693                 :     910140 :       else if (ALLOCNO_ASSIGNED_P (allocno))
    2694                 :            :         {
    2695                 :     910140 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2696                 :          0 :             fprintf (ira_dump_file, "spill%s\n",
    2697                 :          0 :                      ALLOCNO_COLOR_DATA (allocno)->may_be_spilled_p
    2698                 :          0 :                      ? "" : "!");
    2699                 :            :         }
    2700                 :   14476100 :       ALLOCNO_COLOR_DATA (allocno)->in_graph_p = true;
    2701                 :            :     }
    2702                 :     792963 : }
    2703                 :            : 
    2704                 :            : /* Set up number of available hard registers for allocno A.  */
    2705                 :            : static void
    2706                 :   14476100 : setup_allocno_available_regs_num (ira_allocno_t a)
    2707                 :            : {
    2708                 :   14476100 :   int i, n, hard_regno, hard_regs_num, nwords;
    2709                 :   14476100 :   enum reg_class aclass;
    2710                 :   14476100 :   allocno_color_data_t data;
    2711                 :            : 
    2712                 :   14476100 :   aclass = ALLOCNO_CLASS (a);
    2713                 :   14476100 :   data = ALLOCNO_COLOR_DATA (a);
    2714                 :   14476100 :   data->available_regs_num = 0;
    2715                 :   14476100 :   if (aclass == NO_REGS)
    2716                 :            :     return;
    2717                 :   14476100 :   hard_regs_num = ira_class_hard_regs_num[aclass];
    2718                 :   14476100 :   nwords = ALLOCNO_NUM_OBJECTS (a);
    2719                 :  214759000 :   for (n = 0, i = hard_regs_num - 1; i >= 0; i--)
    2720                 :            :     {
    2721                 :  200283000 :       hard_regno = ira_class_hard_regs[aclass][i];
    2722                 :            :       /* Checking only profitable hard regs.  */
    2723                 :  200283000 :       if (TEST_HARD_REG_BIT (data->profitable_hard_regs, hard_regno))
    2724                 :  184719000 :         n++;
    2725                 :            :     }
    2726                 :   14476100 :   data->available_regs_num = n;
    2727                 :   14476100 :   if (internal_flag_ira_verbose <= 2 || ira_dump_file == NULL)
    2728                 :            :     return;
    2729                 :        498 :   fprintf
    2730                 :        498 :     (ira_dump_file,
    2731                 :            :      "      Allocno a%dr%d of %s(%d) has %d avail. regs ",
    2732                 :            :      ALLOCNO_NUM (a), ALLOCNO_REGNO (a),
    2733                 :            :      reg_class_names[aclass], ira_class_hard_regs_num[aclass], n);
    2734                 :        498 :   print_hard_reg_set (ira_dump_file, data->profitable_hard_regs, false);
    2735                 :        498 :   fprintf (ira_dump_file, ", %snode: ",
    2736                 :        996 :            data->profitable_hard_regs == data->hard_regs_node->hard_regs->set
    2737                 :            :            ? "" : "^");
    2738                 :        498 :   print_hard_reg_set (ira_dump_file,
    2739                 :        498 :                       data->hard_regs_node->hard_regs->set, false);
    2740                 :        996 :   for (i = 0; i < nwords; i++)
    2741                 :            :     {
    2742                 :        498 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2743                 :            : 
    2744                 :        498 :       if (nwords != 1)
    2745                 :            :         {
    2746                 :          0 :           if (i != 0)
    2747                 :          0 :             fprintf (ira_dump_file, ", ");
    2748                 :          0 :           fprintf (ira_dump_file, " obj %d", i);
    2749                 :            :         }
    2750                 :        498 :       fprintf (ira_dump_file, " (confl regs = ");
    2751                 :        498 :       print_hard_reg_set (ira_dump_file, OBJECT_TOTAL_CONFLICT_HARD_REGS (obj),
    2752                 :            :                           false);
    2753                 :        498 :       fprintf (ira_dump_file, ")");
    2754                 :            :     }
    2755                 :        498 :   fprintf (ira_dump_file, "\n");
    2756                 :            : }
    2757                 :            : 
    2758                 :            : /* Put ALLOCNO in a bucket corresponding to its number and size of its
    2759                 :            :    conflicting allocnos and hard registers.  */
    2760                 :            : static void
    2761                 :   14476100 : put_allocno_into_bucket (ira_allocno_t allocno)
    2762                 :            : {
    2763                 :   14476100 :   ALLOCNO_COLOR_DATA (allocno)->in_graph_p = true;
    2764                 :   14476100 :   setup_allocno_available_regs_num (allocno);
    2765                 :   14476100 :   if (setup_left_conflict_sizes_p (allocno))
    2766                 :   10062100 :     add_allocno_to_bucket (allocno, &colorable_allocno_bucket);
    2767                 :            :   else
    2768                 :    4414000 :     add_allocno_to_bucket (allocno, &uncolorable_allocno_bucket);
    2769                 :   14476100 : }
    2770                 :            : 
    2771                 :            : /* Map: allocno number -> allocno priority.  */
    2772                 :            : static int *allocno_priorities;
    2773                 :            : 
    2774                 :            : /* Set up priorities for N allocnos in array
    2775                 :            :    CONSIDERATION_ALLOCNOS.  */
    2776                 :            : static void
    2777                 :     255575 : setup_allocno_priorities (ira_allocno_t *consideration_allocnos, int n)
    2778                 :            : {
    2779                 :     255575 :   int i, length, nrefs, priority, max_priority, mult;
    2780                 :     255575 :   ira_allocno_t a;
    2781                 :            : 
    2782                 :     255575 :   max_priority = 0;
    2783                 :    6211940 :   for (i = 0; i < n; i++)
    2784                 :            :     {
    2785                 :    5956360 :       a = consideration_allocnos[i];
    2786                 :    5956360 :       nrefs = ALLOCNO_NREFS (a);
    2787                 :    5956360 :       ira_assert (nrefs >= 0);
    2788                 :    5956360 :       mult = floor_log2 (ALLOCNO_NREFS (a)) + 1;
    2789                 :    5956360 :       ira_assert (mult >= 0);
    2790                 :    5956360 :       allocno_priorities[ALLOCNO_NUM (a)]
    2791                 :    5956360 :         = priority
    2792                 :    5956360 :         = (mult
    2793                 :    5956360 :            * (ALLOCNO_MEMORY_COST (a) - ALLOCNO_CLASS_COST (a))
    2794                 :    5956360 :            * ira_reg_class_max_nregs[ALLOCNO_CLASS (a)][ALLOCNO_MODE (a)]);
    2795                 :    5956360 :       if (priority < 0)
    2796                 :            :         priority = -priority;
    2797                 :    5956360 :       if (max_priority < priority)
    2798                 :            :         max_priority = priority;
    2799                 :            :     }
    2800                 :     255575 :   mult = max_priority == 0 ? 1 : INT_MAX / max_priority;
    2801                 :    6211940 :   for (i = 0; i < n; i++)
    2802                 :            :     {
    2803                 :    5956360 :       a = consideration_allocnos[i];
    2804                 :    5956360 :       length = ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a);
    2805                 :    5956360 :       if (ALLOCNO_NUM_OBJECTS (a) > 1)
    2806                 :     263414 :         length /= ALLOCNO_NUM_OBJECTS (a);
    2807                 :    5956360 :       if (length <= 0)
    2808                 :            :         length = 1;
    2809                 :    5956360 :       allocno_priorities[ALLOCNO_NUM (a)]
    2810                 :    5956360 :         = allocno_priorities[ALLOCNO_NUM (a)] * mult / length;
    2811                 :            :     }
    2812                 :     255575 : }
    2813                 :            : 
    2814                 :            : /* Sort allocnos according to the profit of usage of a hard register
    2815                 :            :    instead of memory for them. */
    2816                 :            : static int
    2817                 :    1914640 : allocno_cost_compare_func (const void *v1p, const void *v2p)
    2818                 :            : {
    2819                 :    1914640 :   ira_allocno_t p1 = *(const ira_allocno_t *) v1p;
    2820                 :    1914640 :   ira_allocno_t p2 = *(const ira_allocno_t *) v2p;
    2821                 :    1914640 :   int c1, c2;
    2822                 :            : 
    2823                 :    1914640 :   c1 = ALLOCNO_UPDATED_MEMORY_COST (p1) - ALLOCNO_UPDATED_CLASS_COST (p1);
    2824                 :    1914640 :   c2 = ALLOCNO_UPDATED_MEMORY_COST (p2) - ALLOCNO_UPDATED_CLASS_COST (p2);
    2825                 :    1914640 :   if (c1 - c2)
    2826                 :    1650780 :     return c1 - c2;
    2827                 :            : 
    2828                 :            :   /* If regs are equally good, sort by allocno numbers, so that the
    2829                 :            :      results of qsort leave nothing to chance.  */
    2830                 :     263861 :   return ALLOCNO_NUM (p1) - ALLOCNO_NUM (p2);
    2831                 :            : }
    2832                 :            : 
    2833                 :            : /* Return savings on removed copies when ALLOCNO is assigned to
    2834                 :            :    HARD_REGNO.  */
    2835                 :            : static int
    2836                 :  181214000 : allocno_copy_cost_saving (ira_allocno_t allocno, int hard_regno)
    2837                 :            : {
    2838                 :  181214000 :   int cost = 0;
    2839                 :  181214000 :   machine_mode allocno_mode = ALLOCNO_MODE (allocno);
    2840                 :  181214000 :   enum reg_class rclass;
    2841                 :  181214000 :   ira_copy_t cp, next_cp;
    2842                 :            : 
    2843                 :  181214000 :   rclass = REGNO_REG_CLASS (hard_regno);
    2844                 :  181214000 :   if (ira_reg_class_max_nregs[rclass][allocno_mode]
    2845                 :  181214000 :       > ira_class_hard_regs_num[rclass])
    2846                 :            :     /* For the above condition the cost can be wrong.  Use the allocno
    2847                 :            :        class in this case.  */
    2848                 :    3623210 :     rclass = ALLOCNO_CLASS (allocno);
    2849                 :  314185000 :   for (cp = ALLOCNO_COPIES (allocno); cp != NULL; cp = next_cp)
    2850                 :            :     {
    2851                 :  132971000 :       if (cp->first == allocno)
    2852                 :            :         {
    2853                 :   63945900 :           next_cp = cp->next_first_allocno_copy;
    2854                 :   63945900 :           if (ALLOCNO_HARD_REGNO (cp->second) != hard_regno)
    2855                 :   40644100 :             continue;
    2856                 :            :         }
    2857                 :   69025200 :       else if (cp->second == allocno)
    2858                 :            :         {
    2859                 :   69025200 :           next_cp = cp->next_second_allocno_copy;
    2860                 :   69025200 :           if (ALLOCNO_HARD_REGNO (cp->first) != hard_regno)
    2861                 :   44339100 :             continue;
    2862                 :            :         }
    2863                 :            :       else
    2864                 :          0 :         gcc_unreachable ();
    2865                 :   47988000 :       ira_init_register_move_cost_if_necessary (allocno_mode);
    2866                 :   47988000 :       cost += cp->freq * ira_register_move_cost[allocno_mode][rclass][rclass];
    2867                 :            :     }
    2868                 :  181214000 :   return cost;
    2869                 :            : }
    2870                 :            : 
    2871                 :            : /* We used Chaitin-Briggs coloring to assign as many pseudos as
    2872                 :            :    possible to hard registers.  Let us try to improve allocation with
    2873                 :            :    cost point of view.  This function improves the allocation by
    2874                 :            :    spilling some allocnos and assigning the freed hard registers to
    2875                 :            :    other allocnos if it decreases the overall allocation cost.  */
    2876                 :            : static void
    2877                 :     792991 : improve_allocation (void)
    2878                 :            : {
    2879                 :     792991 :   unsigned int i;
    2880                 :     792991 :   int j, k, n, hregno, conflict_hregno, base_cost, class_size, word, nwords;
    2881                 :     792991 :   int check, spill_cost, min_cost, nregs, conflict_nregs, r, best;
    2882                 :     792991 :   bool try_p;
    2883                 :     792991 :   enum reg_class aclass;
    2884                 :     792991 :   machine_mode mode;
    2885                 :     792991 :   int *allocno_costs;
    2886                 :     792991 :   int costs[FIRST_PSEUDO_REGISTER];
    2887                 :     792991 :   HARD_REG_SET conflicting_regs[2], profitable_hard_regs;
    2888                 :     792991 :   ira_allocno_t a;
    2889                 :     792991 :   bitmap_iterator bi;
    2890                 :            : 
    2891                 :            :   /* Don't bother to optimize the code with static chain pointer and
    2892                 :            :      non-local goto in order not to spill the chain pointer
    2893                 :            :      pseudo.  */
    2894                 :     792991 :   if (cfun->static_chain_decl && crtl->has_nonlocal_goto)
    2895                 :     733353 :     return;
    2896                 :            :   /* Clear counts used to process conflicting allocnos only once for
    2897                 :            :      each allocno.  */
    2898                 :   17119200 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    2899                 :   16326600 :     ALLOCNO_COLOR_DATA (ira_allocnos[i])->temp = 0;
    2900                 :     792642 :   check = n = 0;
    2901                 :            :   /* Process each allocno and try to assign a hard register to it by
    2902                 :            :      spilling some its conflicting allocnos.  */
    2903                 :   17119200 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    2904                 :            :     {
    2905                 :   16326600 :       a = ira_allocnos[i];
    2906                 :   16326600 :       ALLOCNO_COLOR_DATA (a)->temp = 0;
    2907                 :   32653100 :       if (empty_profitable_hard_regs (a))
    2908                 :    1850880 :         continue;
    2909                 :   14475700 :       check++;
    2910                 :   14475700 :       aclass = ALLOCNO_CLASS (a);
    2911                 :   14475700 :       allocno_costs = ALLOCNO_HARD_REG_COSTS (a);
    2912                 :   14475700 :       if ((hregno = ALLOCNO_HARD_REGNO (a)) < 0)
    2913                 :    1035800 :         base_cost = ALLOCNO_UPDATED_MEMORY_COST (a);
    2914                 :   13439900 :       else if (allocno_costs == NULL)
    2915                 :            :         /* It means that assigning a hard register is not profitable
    2916                 :            :            (we don't waste memory for hard register costs in this
    2917                 :            :            case).  */
    2918                 :    7735270 :         continue;
    2919                 :            :       else
    2920                 :    5704610 :         base_cost = (allocno_costs[ira_class_hard_reg_index[aclass][hregno]]
    2921                 :    5704610 :                      - allocno_copy_cost_saving (a, hregno));
    2922                 :    6740420 :       try_p = false;
    2923                 :    6740420 :       get_conflict_and_start_profitable_regs (a, false,
    2924                 :            :                                               conflicting_regs,
    2925                 :            :                                               &profitable_hard_regs);
    2926                 :    6740420 :       class_size = ira_class_hard_regs_num[aclass];
    2927                 :            :       /* Set up cost improvement for usage of each profitable hard
    2928                 :            :          register for allocno A.  */
    2929                 :  106079000 :       for (j = 0; j < class_size; j++)
    2930                 :            :         {
    2931                 :   99338100 :           hregno = ira_class_hard_regs[aclass][j];
    2932                 :   99338100 :           if (! check_hard_reg_p (a, hregno,
    2933                 :            :                                   conflicting_regs, profitable_hard_regs))
    2934                 :   14032800 :             continue;
    2935                 :   85305200 :           ira_assert (ira_class_hard_reg_index[aclass][hregno] == j);
    2936                 :   85305200 :           k = allocno_costs == NULL ? 0 : j;
    2937                 :   85305200 :           costs[hregno] = (allocno_costs == NULL
    2938                 :   85305200 :                            ? ALLOCNO_UPDATED_CLASS_COST (a) : allocno_costs[k]);
    2939                 :   85305200 :           costs[hregno] -= allocno_copy_cost_saving (a, hregno);
    2940                 :   85305200 :           costs[hregno] -= base_cost;
    2941                 :   85305200 :           if (costs[hregno] < 0)
    2942                 :    8865070 :             try_p = true;
    2943                 :            :         }
    2944                 :    6740420 :       if (! try_p)
    2945                 :            :         /* There is no chance to improve the allocation cost by
    2946                 :            :            assigning hard register to allocno A even without spilling
    2947                 :            :            conflicting allocnos.  */
    2948                 :    5387690 :         continue;
    2949                 :    1352730 :       mode = ALLOCNO_MODE (a);
    2950                 :    1352730 :       nwords = ALLOCNO_NUM_OBJECTS (a);
    2951                 :            :       /* Process each allocno conflicting with A and update the cost
    2952                 :            :          improvement for profitable hard registers of A.  To use a
    2953                 :            :          hard register for A we need to spill some conflicting
    2954                 :            :          allocnos and that creates penalty for the cost
    2955                 :            :          improvement.  */
    2956                 :    2771640 :       for (word = 0; word < nwords; word++)
    2957                 :            :         {
    2958                 :    1418910 :           ira_object_t conflict_obj;
    2959                 :    1418910 :           ira_object_t obj = ALLOCNO_OBJECT (a, word);
    2960                 :    1418910 :           ira_object_conflict_iterator oci;
    2961                 :            :       
    2962                 :  163499000 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    2963                 :            :             {
    2964                 :  162080000 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    2965                 :            : 
    2966                 :  162080000 :               if (ALLOCNO_COLOR_DATA (conflict_a)->temp == check)
    2967                 :            :                 /* We already processed this conflicting allocno
    2968                 :            :                    because we processed earlier another object of the
    2969                 :            :                    conflicting allocno.  */
    2970                 :    8412810 :                 continue;
    2971                 :  153667000 :               ALLOCNO_COLOR_DATA (conflict_a)->temp = check;
    2972                 :  153667000 :               if ((conflict_hregno = ALLOCNO_HARD_REGNO (conflict_a)) < 0)
    2973                 :   63463300 :                 continue;
    2974                 :   90203700 :               spill_cost = ALLOCNO_UPDATED_MEMORY_COST (conflict_a);
    2975                 :   90203700 :               k = (ira_class_hard_reg_index
    2976                 :   90203700 :                    [ALLOCNO_CLASS (conflict_a)][conflict_hregno]);
    2977                 :   90203700 :               ira_assert (k >= 0);
    2978                 :   90203700 :               if ((allocno_costs = ALLOCNO_HARD_REG_COSTS (conflict_a))
    2979                 :            :                   != NULL)
    2980                 :   26565800 :                 spill_cost -= allocno_costs[k];
    2981                 :            :               else
    2982                 :   63637900 :                 spill_cost -= ALLOCNO_UPDATED_CLASS_COST (conflict_a);
    2983                 :   90203700 :               spill_cost
    2984                 :   90203700 :                 += allocno_copy_cost_saving (conflict_a, conflict_hregno);
    2985                 :   90203700 :               conflict_nregs = hard_regno_nregs (conflict_hregno,
    2986                 :   90203700 :                                                  ALLOCNO_MODE (conflict_a));
    2987                 :  182598000 :               for (r = conflict_hregno;
    2988                 :  182598000 :                    r >= 0 && (int) end_hard_regno (mode, r) > conflict_hregno;
    2989                 :            :                    r--)
    2990                 :   92393800 :                 if (check_hard_reg_p (a, r,
    2991                 :            :                                       conflicting_regs, profitable_hard_regs))
    2992                 :   53214700 :                   costs[r] += spill_cost;
    2993                 :   92413100 :               for (r = conflict_hregno + 1;
    2994                 :   92413100 :                    r < conflict_hregno + conflict_nregs;
    2995                 :            :                    r++)
    2996                 :    2209450 :                 if (check_hard_reg_p (a, r,
    2997                 :            :                                       conflicting_regs, profitable_hard_regs))
    2998                 :     687467 :                   costs[r] += spill_cost;
    2999                 :            :             }
    3000                 :            :         }
    3001                 :            :       min_cost = INT_MAX;
    3002                 :            :       best = -1;
    3003                 :            :       /* Now we choose hard register for A which results in highest
    3004                 :            :          allocation cost improvement.  */
    3005                 :   17424600 :       for (j = 0; j < class_size; j++)
    3006                 :            :         {
    3007                 :   16071900 :           hregno = ira_class_hard_regs[aclass][j];
    3008                 :   16071900 :           if (check_hard_reg_p (a, hregno,
    3009                 :            :                                 conflicting_regs, profitable_hard_regs)
    3010                 :   16071900 :               && min_cost > costs[hregno])
    3011                 :            :             {
    3012                 :    4476700 :               best = hregno;
    3013                 :    4476700 :               min_cost = costs[hregno];
    3014                 :            :             }
    3015                 :            :         }
    3016                 :    1352730 :       if (min_cost >= 0)
    3017                 :            :         /* We are in a situation when assigning any hard register to A
    3018                 :            :            by spilling some conflicting allocnos does not improve the
    3019                 :            :            allocation cost.  */
    3020                 :    1135870 :         continue;
    3021                 :     216855 :       nregs = hard_regno_nregs (best, mode);
    3022                 :            :       /* Now spill conflicting allocnos which contain a hard register
    3023                 :            :          of A when we assign the best chosen hard register to it.  */
    3024                 :     439560 :       for (word = 0; word < nwords; word++)
    3025                 :            :         {
    3026                 :     222705 :           ira_object_t conflict_obj;
    3027                 :     222705 :           ira_object_t obj = ALLOCNO_OBJECT (a, word);
    3028                 :     222705 :           ira_object_conflict_iterator oci;
    3029                 :            :       
    3030                 :   10506900 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    3031                 :            :             {
    3032                 :   10284200 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    3033                 :            : 
    3034                 :   10284200 :               if ((conflict_hregno = ALLOCNO_HARD_REGNO (conflict_a)) < 0)
    3035                 :    4754580 :                 continue;
    3036                 :    5529620 :               conflict_nregs = hard_regno_nregs (conflict_hregno,
    3037                 :    5529620 :                                                  ALLOCNO_MODE (conflict_a));
    3038                 :    5529620 :               if (best + nregs <= conflict_hregno
    3039                 :    4720280 :                   || conflict_hregno + conflict_nregs <= best)
    3040                 :            :                 /* No intersection.  */
    3041                 :    5336580 :                 continue;
    3042                 :     193046 :               ALLOCNO_HARD_REGNO (conflict_a) = -1;
    3043                 :     193046 :               sorted_allocnos[n++] = conflict_a;
    3044                 :     193046 :               if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
    3045                 :          0 :                 fprintf (ira_dump_file, "Spilling a%dr%d for a%dr%d\n",
    3046                 :            :                          ALLOCNO_NUM (conflict_a), ALLOCNO_REGNO (conflict_a),
    3047                 :            :                          ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
    3048                 :            :             }
    3049                 :            :         }
    3050                 :            :       /* Assign the best chosen hard register to A.  */
    3051                 :     216855 :       ALLOCNO_HARD_REGNO (a) = best;
    3052                 :     216855 :       if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
    3053                 :          1 :         fprintf (ira_dump_file, "Assigning %d to a%dr%d\n",
    3054                 :            :                  best, ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
    3055                 :            :     }
    3056                 :     792642 :   if (n == 0)
    3057                 :            :     return;
    3058                 :            :   /* We spilled some allocnos to assign their hard registers to other
    3059                 :            :      allocnos.  The spilled allocnos are now in array
    3060                 :            :      'sorted_allocnos'.  There is still a possibility that some of the
    3061                 :            :      spilled allocnos can get hard registers.  So let us try assign
    3062                 :            :      them hard registers again (just a reminder -- function
    3063                 :            :      'assign_hard_reg' assigns hard registers only if it is possible
    3064                 :            :      and profitable).  We process the spilled allocnos with biggest
    3065                 :            :      benefit to get hard register first -- see function
    3066                 :            :      'allocno_cost_compare_func'.  */
    3067                 :      59638 :   qsort (sorted_allocnos, n, sizeof (ira_allocno_t),
    3068                 :            :          allocno_cost_compare_func);
    3069                 :     252684 :   for (j = 0; j < n; j++)
    3070                 :            :     {
    3071                 :     193046 :       a = sorted_allocnos[j];
    3072                 :     193046 :       ALLOCNO_ASSIGNED_P (a) = false;
    3073                 :     193046 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3074                 :            :         {
    3075                 :          0 :           fprintf (ira_dump_file, "      ");
    3076                 :          0 :           ira_print_expanded_allocno (a);
    3077                 :          0 :           fprintf (ira_dump_file, "  -- ");
    3078                 :            :         }
    3079                 :     193046 :       if (assign_hard_reg (a, false))
    3080                 :            :         {
    3081                 :      41144 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3082                 :          0 :             fprintf (ira_dump_file, "assign hard reg %d\n",
    3083                 :          0 :                      ALLOCNO_HARD_REGNO (a));
    3084                 :            :         }
    3085                 :            :       else
    3086                 :            :         {
    3087                 :     151902 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3088                 :          0 :             fprintf (ira_dump_file, "assign memory\n");
    3089                 :            :         }
    3090                 :            :     }
    3091                 :            : }
    3092                 :            : 
    3093                 :            : /* Sort allocnos according to their priorities.  */
    3094                 :            : static int
    3095                 :  212144000 : allocno_priority_compare_func (const void *v1p, const void *v2p)
    3096                 :            : {
    3097                 :  212144000 :   ira_allocno_t a1 = *(const ira_allocno_t *) v1p;
    3098                 :  212144000 :   ira_allocno_t a2 = *(const ira_allocno_t *) v2p;
    3099                 :  212144000 :   int pri1, pri2, diff;
    3100                 :            : 
    3101                 :            :   /* Assign hard reg to static chain pointer pseudo first when
    3102                 :            :      non-local goto is used.  */
    3103                 :  212144000 :   if ((diff = (non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a2))
    3104                 :  424288000 :                - non_spilled_static_chain_regno_p (ALLOCNO_REGNO (a1)))) != 0)
    3105                 :            :     return diff;
    3106                 :  212143000 :   pri1 = allocno_priorities[ALLOCNO_NUM (a1)];
    3107                 :  212143000 :   pri2 = allocno_priorities[ALLOCNO_NUM (a2)];
    3108                 :  212143000 :   if (pri2 != pri1)
    3109                 :  104569000 :     return SORTGT (pri2, pri1);
    3110                 :            : 
    3111                 :            :   /* If regs are equally good, sort by allocnos, so that the results of
    3112                 :            :      qsort leave nothing to chance.  */
    3113                 :  146021000 :   return ALLOCNO_NUM (a1) - ALLOCNO_NUM (a2);
    3114                 :            : }
    3115                 :            : 
    3116                 :            : /* Chaitin-Briggs coloring for allocnos in COLORING_ALLOCNO_BITMAP
    3117                 :            :    taking into account allocnos in CONSIDERATION_ALLOCNO_BITMAP.  */
    3118                 :            : static void
    3119                 :     792991 : color_allocnos (void)
    3120                 :            : {
    3121                 :     792991 :   unsigned int i, n;
    3122                 :     792991 :   bitmap_iterator bi;
    3123                 :     792991 :   ira_allocno_t a;
    3124                 :            : 
    3125                 :     792991 :   setup_profitable_hard_regs ();
    3126                 :   17121200 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    3127                 :            :     {
    3128                 :   16328200 :       allocno_color_data_t data;
    3129                 :   16328200 :       ira_pref_t pref, next_pref;
    3130                 :            : 
    3131                 :   16328200 :       a = ira_allocnos[i];
    3132                 :   16328200 :       data = ALLOCNO_COLOR_DATA (a);
    3133                 :   16328200 :       data->conflict_allocno_hard_prefs = 0;
    3134                 :   20128100 :       for (pref = ALLOCNO_PREFS (a); pref != NULL; pref = next_pref)
    3135                 :            :         {
    3136                 :    3799930 :           next_pref = pref->next_pref;
    3137                 :    3799930 :           if (! ira_hard_reg_in_set_p (pref->hard_regno,
    3138                 :    3799930 :                                        ALLOCNO_MODE (a),
    3139                 :            :                                        data->profitable_hard_regs))
    3140                 :     377069 :             ira_remove_pref (pref);
    3141                 :            :         }
    3142                 :            :     }
    3143                 :            :   
    3144                 :     792991 :   if (flag_ira_algorithm == IRA_ALGORITHM_PRIORITY)
    3145                 :            :     {
    3146                 :         28 :       n = 0;
    3147                 :       1259 :       EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    3148                 :            :         {
    3149                 :       1231 :           a = ira_allocnos[i];
    3150                 :       1231 :           if (ALLOCNO_CLASS (a) == NO_REGS)
    3151                 :            :             {
    3152                 :         51 :               ALLOCNO_HARD_REGNO (a) = -1;
    3153                 :         51 :               ALLOCNO_ASSIGNED_P (a) = true;
    3154                 :         51 :               ira_assert (ALLOCNO_UPDATED_HARD_REG_COSTS (a) == NULL);
    3155                 :         51 :               ira_assert (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) == NULL);
    3156                 :         51 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3157                 :            :                 {
    3158                 :          0 :                   fprintf (ira_dump_file, "      Spill");
    3159                 :          0 :                   ira_print_expanded_allocno (a);
    3160                 :          0 :                   fprintf (ira_dump_file, "\n");
    3161                 :            :                 }
    3162                 :         51 :               continue;
    3163                 :            :             }
    3164                 :       1180 :           sorted_allocnos[n++] = a;
    3165                 :            :         }
    3166                 :         28 :       if (n != 0)
    3167                 :            :         {
    3168                 :         27 :           setup_allocno_priorities (sorted_allocnos, n);
    3169                 :         27 :           qsort (sorted_allocnos, n, sizeof (ira_allocno_t),
    3170                 :            :                  allocno_priority_compare_func);
    3171                 :       1207 :           for (i = 0; i < n; i++)
    3172                 :            :             {
    3173                 :       1180 :               a = sorted_allocnos[i];
    3174                 :       1180 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3175                 :            :                 {
    3176                 :          0 :                   fprintf (ira_dump_file, "      ");
    3177                 :          0 :                   ira_print_expanded_allocno (a);
    3178                 :          0 :                   fprintf (ira_dump_file, "  -- ");
    3179                 :            :                 }
    3180                 :       1180 :               if (assign_hard_reg (a, false))
    3181                 :            :                 {
    3182                 :       1101 :                   if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3183                 :          0 :                     fprintf (ira_dump_file, "assign hard reg %d\n",
    3184                 :          0 :                              ALLOCNO_HARD_REGNO (a));
    3185                 :            :                 }
    3186                 :            :               else
    3187                 :            :                 {
    3188                 :         79 :                   if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3189                 :          0 :                     fprintf (ira_dump_file, "assign memory\n");
    3190                 :            :                 }
    3191                 :            :             }
    3192                 :            :         }
    3193                 :            :     }
    3194                 :            :   else
    3195                 :            :     {
    3196                 :     792963 :       form_allocno_hard_regs_nodes_forest ();
    3197                 :     792963 :       if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
    3198                 :         39 :         print_hard_regs_forest (ira_dump_file);
    3199                 :   17119900 :       EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    3200                 :            :         {
    3201                 :   16327000 :           a = ira_allocnos[i];
    3202                 :   31882300 :           if (ALLOCNO_CLASS (a) != NO_REGS && ! empty_profitable_hard_regs (a))
    3203                 :            :             {
    3204                 :   14476100 :               ALLOCNO_COLOR_DATA (a)->in_graph_p = true;
    3205                 :   14476100 :               update_costs_from_prefs (a);
    3206                 :   14476100 :               update_conflict_allocno_hard_prefs (a);
    3207                 :            :             }
    3208                 :            :           else
    3209                 :            :             {
    3210                 :    1850830 :               ALLOCNO_HARD_REGNO (a) = -1;
    3211                 :    1850830 :               ALLOCNO_ASSIGNED_P (a) = true;
    3212                 :            :               /* We don't need updated costs anymore.  */
    3213                 :    1850830 :               ira_free_allocno_updated_costs (a);
    3214                 :    1850830 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3215                 :            :                 {
    3216                 :         33 :                   fprintf (ira_dump_file, "      Spill");
    3217                 :         33 :                   ira_print_expanded_allocno (a);
    3218                 :         33 :                   fprintf (ira_dump_file, "\n");
    3219                 :            :                 }
    3220                 :            :             }
    3221                 :            :         }
    3222                 :            :       /* Put the allocnos into the corresponding buckets.  */
    3223                 :     792963 :       colorable_allocno_bucket = NULL;
    3224                 :     792963 :       uncolorable_allocno_bucket = NULL;
    3225                 :   17119900 :       EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
    3226                 :            :         {
    3227                 :   16327000 :           a = ira_allocnos[i];
    3228                 :   16327000 :           if (ALLOCNO_COLOR_DATA (a)->in_graph_p)
    3229                 :   14476100 :             put_allocno_into_bucket (a);
    3230                 :            :         }
    3231                 :     792963 :       push_allocnos_to_stack ();
    3232                 :     792963 :       pop_allocnos_from_stack ();
    3233                 :     792963 :       finish_allocno_hard_regs_nodes_forest ();
    3234                 :            :     }
    3235                 :     792991 :   improve_allocation ();
    3236                 :     792991 : }
    3237                 :            : 
    3238                 :            : 
    3239                 :            : 
    3240                 :            : /* Output information about the loop given by its LOOP_TREE_NODE.  */
    3241                 :            : static void
    3242                 :         39 : print_loop_title (ira_loop_tree_node_t loop_tree_node)
    3243                 :            : {
    3244                 :         39 :   unsigned int j;
    3245                 :         39 :   bitmap_iterator bi;
    3246                 :         39 :   ira_loop_tree_node_t subloop_node, dest_loop_node;
    3247                 :         39 :   edge e;
    3248                 :         39 :   edge_iterator ei;
    3249                 :            : 
    3250                 :         39 :   if (loop_tree_node->parent == NULL)
    3251                 :         39 :     fprintf (ira_dump_file,
    3252                 :            :              "\n  Loop 0 (parent -1, header bb%d, depth 0)\n    bbs:",
    3253                 :            :              NUM_FIXED_BLOCKS);
    3254                 :            :   else
    3255                 :            :     {
    3256                 :          0 :       ira_assert (current_loops != NULL && loop_tree_node->loop != NULL);
    3257                 :          0 :       fprintf (ira_dump_file,
    3258                 :            :                "\n  Loop %d (parent %d, header bb%d, depth %d)\n    bbs:",
    3259                 :            :                loop_tree_node->loop_num, loop_tree_node->parent->loop_num,
    3260                 :          0 :                loop_tree_node->loop->header->index,
    3261                 :            :                loop_depth (loop_tree_node->loop));
    3262                 :            :     }
    3263                 :         39 :   for (subloop_node = loop_tree_node->children;
    3264                 :        315 :        subloop_node != NULL;
    3265                 :        276 :        subloop_node = subloop_node->next)
    3266                 :        276 :     if (subloop_node->bb != NULL)
    3267                 :            :       {
    3268                 :        276 :         fprintf (ira_dump_file, " %d", subloop_node->bb->index);
    3269                 :        679 :         FOR_EACH_EDGE (e, ei, subloop_node->bb->succs)
    3270                 :        403 :           if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
    3271                 :        403 :               && ((dest_loop_node = IRA_BB_NODE (e->dest)->parent)
    3272                 :            :                   != loop_tree_node))
    3273                 :          0 :             fprintf (ira_dump_file, "(->%d:l%d)",
    3274                 :            :                      e->dest->index, dest_loop_node->loop_num);
    3275                 :            :       }
    3276                 :         39 :   fprintf (ira_dump_file, "\n    all:");
    3277                 :        570 :   EXECUTE_IF_SET_IN_BITMAP (loop_tree_node->all_allocnos, 0, j, bi)
    3278                 :        531 :     fprintf (ira_dump_file, " %dr%d", j, ALLOCNO_REGNO (ira_allocnos[j]));
    3279                 :         39 :   fprintf (ira_dump_file, "\n    modified regnos:");
    3280                 :        570 :   EXECUTE_IF_SET_IN_BITMAP (loop_tree_node->modified_regnos, 0, j, bi)
    3281                 :        531 :     fprintf (ira_dump_file, " %d", j);
    3282                 :         39 :   fprintf (ira_dump_file, "\n    border:");
    3283                 :         39 :   EXECUTE_IF_SET_IN_BITMAP (loop_tree_node->border_allocnos, 0, j, bi)
    3284                 :          0 :     fprintf (ira_dump_file, " %dr%d", j, ALLOCNO_REGNO (ira_allocnos[j]));
    3285                 :         39 :   fprintf (ira_dump_file, "\n    Pressure:");
    3286                 :        195 :   for (j = 0; (int) j < ira_pressure_classes_num; j++)
    3287                 :            :     {
    3288                 :        156 :       enum reg_class pclass;
    3289                 :            : 
    3290                 :        156 :       pclass = ira_pressure_classes[j];
    3291                 :        156 :       if (loop_tree_node->reg_pressure[pclass] == 0)
    3292                 :        110 :         continue;
    3293                 :         46 :       fprintf (ira_dump_file, " %s=%d", reg_class_names[pclass],
    3294                 :            :                loop_tree_node->reg_pressure[pclass]);
    3295                 :            :     }
    3296                 :         39 :   fprintf (ira_dump_file, "\n");
    3297                 :         39 : }
    3298                 :            : 
    3299                 :            : /* Color the allocnos inside loop (in the extreme case it can be all
    3300                 :            :    of the function) given the corresponding LOOP_TREE_NODE.  The
    3301                 :            :    function is called for each loop during top-down traverse of the
    3302                 :            :    loop tree.  */
    3303                 :            : static void
    3304                 :     792991 : color_pass (ira_loop_tree_node_t loop_tree_node)
    3305                 :            : {
    3306                 :     792991 :   int regno, hard_regno, index = -1, n;
    3307                 :     792991 :   int cost, exit_freq, enter_freq;
    3308                 :     792991 :   unsigned int j;
    3309                 :     792991 :   bitmap_iterator bi;
    3310                 :     792991 :   machine_mode mode;
    3311                 :     792991 :   enum reg_class rclass, aclass, pclass;
    3312                 :     792991 :   ira_allocno_t a, subloop_allocno;
    3313                 :     792991 :   ira_loop_tree_node_t subloop_node;
    3314                 :            : 
    3315                 :     792991 :   ira_assert (loop_tree_node->bb == NULL);
    3316                 :     792991 :   if (internal_flag_ira_verbose > 1 && ira_dump_file != NULL)
    3317                 :         39 :     print_loop_title (loop_tree_node);
    3318                 :            : 
    3319                 :     792991 :   bitmap_copy (coloring_allocno_bitmap, loop_tree_node->all_allocnos);
    3320                 :     792991 :   bitmap_copy (consideration_allocno_bitmap, coloring_allocno_bitmap);
    3321                 :     792991 :   n = 0;
    3322                 :   17747400 :   EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, j, bi)
    3323                 :            :     {
    3324                 :   16954400 :       a = ira_allocnos[j];
    3325                 :   16954400 :       n++;
    3326                 :   16954400 :       if (! ALLOCNO_ASSIGNED_P (a))
    3327                 :   16328200 :         continue;
    3328                 :     626194 :       bitmap_clear_bit (coloring_allocno_bitmap, ALLOCNO_NUM (a));
    3329                 :            :     }
    3330                 :     792991 :   allocno_color_data
    3331                 :    1585980 :     = (allocno_color_data_t) ira_allocate (sizeof (struct allocno_color_data)
    3332                 :     792991 :                                            * n);
    3333                 :     792991 :   memset (allocno_color_data, 0, sizeof (struct allocno_color_data) * n);
    3334                 :     792991 :   curr_allocno_process = 0;
    3335                 :     792991 :   n = 0;
    3336                 :   17747400 :   EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, j, bi)
    3337                 :            :     {
    3338                 :   16954400 :       a = ira_allocnos[j];
    3339                 :   16954400 :       ALLOCNO_ADD_DATA (a) = allocno_color_data + n;
    3340                 :   16954400 :       n++;
    3341                 :            :     }
    3342                 :     792991 :   init_allocno_threads ();
    3343                 :            :   /* Color all mentioned allocnos including transparent ones.  */
    3344                 :     792991 :   color_allocnos ();
    3345                 :            :   /* Process caps.  They are processed just once.  */
    3346                 :     792991 :   if (flag_ira_region == IRA_REGION_MIXED
    3347                 :     792991 :       || flag_ira_region == IRA_REGION_ALL)
    3348                 :   17318600 :     EXECUTE_IF_SET_IN_BITMAP (loop_tree_node->all_allocnos, 0, j, bi)
    3349                 :            :       {
    3350                 :   16553800 :         a = ira_allocnos[j];
    3351                 :   16553800 :         if (ALLOCNO_CAP_MEMBER (a) == NULL)
    3352                 :   13752900 :           continue;
    3353                 :            :         /* Remove from processing in the next loop.  */
    3354                 :    2800960 :         bitmap_clear_bit (consideration_allocno_bitmap, j);
    3355                 :    2800960 :         rclass = ALLOCNO_CLASS (a);
    3356                 :    2800960 :         pclass = ira_pressure_class_translate[rclass];
    3357                 :    2800960 :         if (flag_ira_region == IRA_REGION_MIXED
    3358                 :    2800960 :             && (loop_tree_node->reg_pressure[pclass]
    3359                 :    2800960 :                 <= ira_class_hard_regs_num[pclass]))
    3360                 :            :           {
    3361                 :     365074 :             mode = ALLOCNO_MODE (a);
    3362                 :     365074 :             hard_regno = ALLOCNO_HARD_REGNO (a);
    3363                 :     365074 :             if (hard_regno >= 0)
    3364                 :            :               {
    3365                 :     198742 :                 index = ira_class_hard_reg_index[rclass][hard_regno];
    3366                 :     198742 :                 ira_assert (index >= 0);
    3367                 :            :               }
    3368                 :     365074 :             regno = ALLOCNO_REGNO (a);
    3369                 :     365074 :             subloop_allocno = ALLOCNO_CAP_MEMBER (a);
    3370                 :     365074 :             subloop_node = ALLOCNO_LOOP_TREE_NODE (subloop_allocno);
    3371                 :     365074 :             ira_assert (!ALLOCNO_ASSIGNED_P (subloop_allocno));
    3372                 :     365074 :             ALLOCNO_HARD_REGNO (subloop_allocno) = hard_regno;
    3373                 :     365074 :             ALLOCNO_ASSIGNED_P (subloop_allocno) = true;
    3374                 :     365074 :             if (hard_regno >= 0)
    3375                 :     198742 :               update_costs_from_copies (subloop_allocno, true, true);
    3376                 :            :             /* We don't need updated costs anymore.  */
    3377                 :     365074 :             ira_free_allocno_updated_costs (subloop_allocno);
    3378                 :            :           }
    3379                 :            :       }
    3380                 :            :   /* Update costs of the corresponding allocnos (not caps) in the
    3381                 :            :      subloops.  */
    3382                 :     792991 :   for (subloop_node = loop_tree_node->subloops;
    3383                 :     897434 :        subloop_node != NULL;
    3384                 :     104443 :        subloop_node = subloop_node->subloop_next)
    3385                 :            :     {
    3386                 :     104443 :       ira_assert (subloop_node->bb == NULL);
    3387                 :   19356600 :       EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, j, bi)
    3388                 :            :         {
    3389                 :   19252200 :           a = ira_allocnos[j];
    3390                 :   19252200 :           ira_assert (ALLOCNO_CAP_MEMBER (a) == NULL);
    3391                 :   19252200 :           mode = ALLOCNO_MODE (a);
    3392                 :   19252200 :           rclass = ALLOCNO_CLASS (a);
    3393                 :   19252200 :           pclass = ira_pressure_class_translate[rclass];
    3394                 :   19252200 :           hard_regno = ALLOCNO_HARD_REGNO (a);
    3395                 :            :           /* Use hard register class here.  ??? */
    3396                 :   19252200 :           if (hard_regno >= 0)
    3397                 :            :             {
    3398                 :   15703300 :               index = ira_class_hard_reg_index[rclass][hard_regno];
    3399                 :   15703300 :               ira_assert (index >= 0);
    3400                 :            :             }
    3401                 :   19252200 :           regno = ALLOCNO_REGNO (a);
    3402                 :            :           /* ??? conflict costs */
    3403                 :   19252200 :           subloop_allocno = subloop_node->regno_allocno_map[regno];
    3404                 :   19252200 :           if (subloop_allocno == NULL
    3405                 :    2153260 :               || ALLOCNO_CAP (subloop_allocno) != NULL)
    3406                 :   17105300 :             continue;
    3407                 :    2146940 :           ira_assert (ALLOCNO_CLASS (subloop_allocno) == rclass);
    3408                 :    2146940 :           ira_assert (bitmap_bit_p (subloop_node->all_allocnos,
    3409                 :            :                                     ALLOCNO_NUM (subloop_allocno)));
    3410                 :    2297650 :           if ((flag_ira_region == IRA_REGION_MIXED
    3411                 :    2146940 :                && (loop_tree_node->reg_pressure[pclass]
    3412                 :    2146940 :                    <= ira_class_hard_regs_num[pclass]))
    3413                 :    2011500 :               || (pic_offset_table_rtx != NULL
    3414                 :     310656 :                   && regno == (int) REGNO (pic_offset_table_rtx))
    3415                 :            :               /* Avoid overlapped multi-registers. Moves between them
    3416                 :            :                  might result in wrong code generation.  */
    3417                 :    4147140 :               || (hard_regno >= 0
    3418                 :     642253 :                   && ira_reg_class_max_nregs[pclass][mode] > 1))
    3419                 :            :             {
    3420                 :     150714 :               if (! ALLOCNO_ASSIGNED_P (subloop_allocno))
    3421                 :            :                 {
    3422                 :     150714 :                   ALLOCNO_HARD_REGNO (subloop_allocno) = hard_regno;
    3423                 :     150714 :                   ALLOCNO_ASSIGNED_P (subloop_allocno) = true;
    3424                 :     150714 :                   if (hard_regno >= 0)
    3425                 :      56463 :                     update_costs_from_copies (subloop_allocno, true, true);
    3426                 :            :                   /* We don't need updated costs anymore.  */
    3427                 :     150714 :                   ira_free_allocno_updated_costs (subloop_allocno);
    3428                 :            :                 }
    3429                 :     150714 :               continue;
    3430                 :            :             }
    3431                 :    1996220 :           exit_freq = ira_loop_edge_freq (subloop_node, regno, true);
    3432                 :    1996220 :           enter_freq = ira_loop_edge_freq (subloop_node, regno, false);
    3433                 :    1996220 :           ira_assert (regno < ira_reg_equiv_len);
    3434                 :    1996220 :           if (ira_equiv_no_lvalue_p (regno))
    3435                 :            :             {
    3436                 :     110406 :               if (! ALLOCNO_ASSIGNED_P (subloop_allocno))
    3437                 :            :                 {
    3438                 :     110406 :                   ALLOCNO_HARD_REGNO (subloop_allocno) = hard_regno;
    3439                 :     110406 :                   ALLOCNO_ASSIGNED_P (subloop_allocno) = true;
    3440                 :     110406 :                   if (hard_regno >= 0)
    3441                 :      33649 :                     update_costs_from_copies (subloop_allocno, true, true);
    3442                 :            :                   /* We don't need updated costs anymore.  */
    3443                 :     110406 :                   ira_free_allocno_updated_costs (subloop_allocno);
    3444                 :            :                 }
    3445                 :            :             }
    3446                 :    1885820 :           else if (hard_regno < 0)
    3447                 :            :             {
    3448                 :    1281190 :               ALLOCNO_UPDATED_MEMORY_COST (subloop_allocno)
    3449                 :    1281190 :                 -= ((ira_memory_move_cost[mode][rclass][1] * enter_freq)
    3450                 :    1281190 :                     + (ira_memory_move_cost[mode][rclass][0] * exit_freq));
    3451                 :            :             }
    3452                 :            :           else
    3453                 :            :             {
    3454                 :     604626 :               aclass = ALLOCNO_CLASS (subloop_allocno);
    3455                 :     604626 :               ira_init_register_move_cost_if_necessary (mode);
    3456                 :     604626 :               cost = (ira_register_move_cost[mode][rclass][rclass]
    3457                 :     604626 :                       * (exit_freq + enter_freq));
    3458                 :     604626 :               ira_allocate_and_set_or_copy_costs
    3459                 :     604626 :                 (&ALLOCNO_UPDATED_HARD_REG_COSTS (subloop_allocno), aclass,
    3460                 :            :                  ALLOCNO_UPDATED_CLASS_COST (subloop_allocno),
    3461                 :            :                  ALLOCNO_HARD_REG_COSTS (subloop_allocno));
    3462                 :     604626 :               ira_allocate_and_set_or_copy_costs
    3463                 :     604626 :                 (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (subloop_allocno),
    3464                 :            :                  aclass, 0, ALLOCNO_CONFLICT_HARD_REG_COSTS (subloop_allocno));
    3465                 :     604626 :               ALLOCNO_UPDATED_HARD_REG_COSTS (subloop_allocno)[index] -= cost;
    3466                 :     604626 :               ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (subloop_allocno)[index]
    3467                 :     604626 :                 -= cost;
    3468                 :     604626 :               if (ALLOCNO_UPDATED_CLASS_COST (subloop_allocno)
    3469                 :     604626 :                   > ALLOCNO_UPDATED_HARD_REG_COSTS (subloop_allocno)[index])
    3470                 :     589520 :                 ALLOCNO_UPDATED_CLASS_COST (subloop_allocno)
    3471                 :     589520 :                   = ALLOCNO_UPDATED_HARD_REG_COSTS (subloop_allocno)[index];
    3472                 :     604626 :               ALLOCNO_UPDATED_MEMORY_COST (subloop_allocno)
    3473                 :     604626 :                 += (ira_memory_move_cost[mode][rclass][0] * enter_freq
    3474                 :     604626 :                     + ira_memory_move_cost[mode][rclass][1] * exit_freq);
    3475                 :            :             }
    3476                 :            :         }
    3477                 :            :     }
    3478                 :     792991 :   ira_free (allocno_color_data);
    3479                 :   14946400 :   EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, j, bi)
    3480                 :            :     {
    3481                 :   14153400 :       a = ira_allocnos[j];
    3482                 :   14153400 :       ALLOCNO_ADD_DATA (a) = NULL;
    3483                 :            :     }
    3484                 :     792991 : }
    3485                 :            : 
    3486                 :            : /* Initialize the common data for coloring and calls functions to do
    3487                 :            :    Chaitin-Briggs and regional coloring.  */
    3488                 :            : static void
    3489                 :     688548 : do_coloring (void)
    3490                 :            : {
    3491                 :     688548 :   coloring_allocno_bitmap = ira_allocate_bitmap ();
    3492                 :     688548 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    3493                 :         39 :     fprintf (ira_dump_file, "\n**** Allocnos coloring:\n\n");
    3494                 :            : 
    3495                 :     688548 :   ira_traverse_loop_tree (false, ira_loop_tree_root, color_pass, NULL);
    3496                 :            : 
    3497                 :     688548 :   if (internal_flag_ira_verbose > 1 && ira_dump_file != NULL)
    3498                 :         39 :     ira_print_disposition (ira_dump_file);
    3499                 :            : 
    3500                 :     688548 :   ira_free_bitmap (coloring_allocno_bitmap);
    3501                 :     688548 : }
    3502                 :            : 
    3503                 :            : 
    3504                 :            : 
    3505                 :            : /* Move spill/restore code, which are to be generated in ira-emit.c,
    3506                 :            :    to less frequent points (if it is profitable) by reassigning some
    3507                 :            :    allocnos (in loop with subloops containing in another loop) to
    3508                 :            :    memory which results in longer live-range where the corresponding
    3509                 :            :    pseudo-registers will be in memory.  */
    3510                 :            : static void
    3511                 :     688548 : move_spill_restore (void)
    3512                 :            : {
    3513                 :     689215 :   int cost, regno, hard_regno, hard_regno2, index;
    3514                 :     689215 :   bool changed_p;
    3515                 :     689215 :   int enter_freq, exit_freq;
    3516                 :     689215 :   machine_mode mode;
    3517                 :     689215 :   enum reg_class rclass;
    3518                 :     689215 :   ira_allocno_t a, parent_allocno, subloop_allocno;
    3519                 :     689215 :   ira_loop_tree_node_t parent, loop_node, subloop_node;
    3520                 :     689215 :   ira_allocno_iterator ai;
    3521                 :            : 
    3522                 :     689215 :   for (;;)
    3523                 :            :     {
    3524                 :     689215 :       changed_p = false;
    3525                 :     689215 :       if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    3526                 :         39 :         fprintf (ira_dump_file, "New iteration of spill/restore move\n");
    3527                 :   18906300 :       FOR_EACH_ALLOCNO (a, ai)
    3528                 :            :         {
    3529                 :   18217000 :           regno = ALLOCNO_REGNO (a);
    3530                 :   18217000 :           loop_node = ALLOCNO_LOOP_TREE_NODE (a);
    3531                 :   35712400 :           if (ALLOCNO_CAP_MEMBER (a) != NULL
    3532                 :   14725100 :               || ALLOCNO_CAP (a) != NULL
    3533                 :   13235300 :               || (hard_regno = ALLOCNO_HARD_REGNO (a)) < 0
    3534                 :   10369700 :               || loop_node->children == NULL
    3535                 :            :               /* don't do the optimization because it can create
    3536                 :            :                  copies and the reload pass can spill the allocno set
    3537                 :            :                  by copy although the allocno will not get memory
    3538                 :            :                  slot.  */
    3539                 :   10369700 :               || ira_equiv_no_lvalue_p (regno)
    3540                 :    9689300 :               || !bitmap_bit_p (loop_node->border_allocnos, ALLOCNO_NUM (a))
    3541                 :            :               /* Do not spill static chain pointer pseudo when
    3542                 :            :                  non-local goto is used.  */
    3543                 :   18217000 :               || non_spilled_static_chain_regno_p (regno))
    3544                 :   17495400 :             continue;
    3545                 :     721646 :           mode = ALLOCNO_MODE (a);
    3546                 :     721646 :           rclass = ALLOCNO_CLASS (a);
    3547                 :     721646 :           index = ira_class_hard_reg_index[rclass][hard_regno];
    3548                 :     721646 :           ira_assert (index >= 0);
    3549                 :    1443290 :           cost = (ALLOCNO_MEMORY_COST (a)
    3550                 :     721646 :                   - (ALLOCNO_HARD_REG_COSTS (a) == NULL
    3551                 :     721646 :                      ? ALLOCNO_CLASS_COST (a)
    3552                 :     159368 :                      : ALLOCNO_HARD_REG_COSTS (a)[index]));
    3553                 :     721646 :           ira_init_register_move_cost_if_necessary (mode);
    3554                 :     721646 :           for (subloop_node = loop_node->subloops;
    3555                 :     956237 :                subloop_node != NULL;
    3556                 :     234591 :                subloop_node = subloop_node->subloop_next)
    3557                 :            :             {
    3558                 :     234591 :               ira_assert (subloop_node->bb == NULL);
    3559                 :     234591 :               subloop_allocno = subloop_node->regno_allocno_map[regno];
    3560                 :     234591 :               if (subloop_allocno == NULL)
    3561                 :      38087 :                 continue;
    3562                 :     196504 :               ira_assert (rclass == ALLOCNO_CLASS (subloop_allocno));
    3563                 :            :               /* We have accumulated cost.  To get the real cost of
    3564                 :            :                  allocno usage in the loop we should subtract costs of
    3565                 :            :                  the subloop allocnos.  */
    3566                 :     393008 :               cost -= (ALLOCNO_MEMORY_COST (subloop_allocno)
    3567                 :     393008 :                        - (ALLOCNO_HARD_REG_COSTS (subloop_allocno) == NULL
    3568                 :     196504 :                           ? ALLOCNO_CLASS_COST (subloop_allocno)
    3569                 :      27785 :                           : ALLOCNO_HARD_REG_COSTS (subloop_allocno)[index]));
    3570                 :     196504 :               exit_freq = ira_loop_edge_freq (subloop_node, regno, true);
    3571                 :     196504 :               enter_freq = ira_loop_edge_freq (subloop_node, regno, false);
    3572                 :     196504 :               if ((hard_regno2 = ALLOCNO_HARD_REGNO (subloop_allocno)) < 0)
    3573                 :      10277 :                 cost -= (ira_memory_move_cost[mode][rclass][0] * exit_freq
    3574                 :      10277 :                          + ira_memory_move_cost[mode][rclass][1] * enter_freq);
    3575                 :            :               else
    3576                 :            :                 {
    3577                 :     186227 :                   cost
    3578                 :     186227 :                     += (ira_memory_move_cost[mode][rclass][0] * exit_freq
    3579                 :     186227 :                         + ira_memory_move_cost[mode][rclass][1] * enter_freq);
    3580                 :     186227 :                   if (hard_regno2 != hard_regno)
    3581                 :       4750 :                     cost -= (ira_register_move_cost[mode][rclass][rclass]
    3582                 :       4750 :                              * (exit_freq + enter_freq));
    3583                 :            :                 }
    3584                 :            :             }
    3585                 :     721646 :           if ((parent = loop_node->parent) != NULL
    3586                 :     721646 :               && (parent_allocno = parent->regno_allocno_map[regno]) != NULL)
    3587                 :            :             {
    3588                 :     721646 :               ira_assert (rclass == ALLOCNO_CLASS (parent_allocno));
    3589                 :     721646 :               exit_freq = ira_loop_edge_freq (loop_node, regno, true);
    3590                 :     721646 :               enter_freq = ira_loop_edge_freq (loop_node, regno, false);
    3591                 :     721646 :               if ((hard_regno2 = ALLOCNO_HARD_REGNO (parent_allocno)) < 0)
    3592                 :      40365 :                 cost -= (ira_memory_move_cost[mode][rclass][0] * exit_freq
    3593                 :      40365 :                          + ira_memory_move_cost[mode][rclass][1] * enter_freq);
    3594                 :            :               else
    3595                 :            :                 {
    3596                 :     681281 :                   cost
    3597                 :     681281 :                     += (ira_memory_move_cost[mode][rclass][1] * exit_freq
    3598                 :     681281 :                         + ira_memory_move_cost[mode][rclass][0] * enter_freq);
    3599                 :     681281 :                   if (hard_regno2 != hard_regno)
    3600                 :      28034 :                     cost -= (ira_register_move_cost[mode][rclass][rclass]
    3601                 :      28034 :                              * (exit_freq + enter_freq));
    3602                 :            :                 }
    3603                 :            :             }
    3604                 :     721646 :           if (cost < 0)
    3605                 :            :             {
    3606                 :       1204 :               ALLOCNO_HARD_REGNO (a) = -1;
    3607                 :       1204 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3608                 :            :                 {
    3609                 :          0 :                   fprintf
    3610                 :          0 :                     (ira_dump_file,
    3611                 :            :                      "      Moving spill/restore for a%dr%d up from loop %d",
    3612                 :            :                      ALLOCNO_NUM (a), regno, loop_node->loop_num);
    3613                 :          0 :                   fprintf (ira_dump_file, " - profit %d\n", -cost);
    3614                 :            :                 }
    3615                 :            :               changed_p = true;
    3616                 :            :             }
    3617                 :            :         }
    3618                 :     689215 :       if (! changed_p)
    3619                 :            :         break;
    3620                 :            :     }
    3621                 :     688548 : }
    3622                 :            : 
    3623                 :            : 
    3624                 :            : 
    3625                 :            : /* Update current hard reg costs and current conflict hard reg costs
    3626                 :            :    for allocno A.  It is done by processing its copies containing
    3627                 :            :    other allocnos already assigned.  */
    3628                 :            : static void
    3629                 :          0 : update_curr_costs (ira_allocno_t a)
    3630                 :            : {
    3631                 :          0 :   int i, hard_regno, cost;
    3632                 :          0 :   machine_mode mode;
    3633                 :          0 :   enum reg_class aclass, rclass;
    3634                 :          0 :   ira_allocno_t another_a;
    3635                 :          0 :   ira_copy_t cp, next_cp;
    3636                 :            : 
    3637                 :          0 :   ira_free_allocno_updated_costs (a);
    3638                 :          0 :   ira_assert (! ALLOCNO_ASSIGNED_P (a));
    3639                 :          0 :   aclass = ALLOCNO_CLASS (a);
    3640                 :          0 :   if (aclass == NO_REGS)
    3641                 :            :     return;
    3642                 :          0 :   mode = ALLOCNO_MODE (a);
    3643                 :          0 :   ira_init_register_move_cost_if_necessary (mode);
    3644                 :          0 :   for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    3645                 :            :     {
    3646                 :          0 :       if (cp->first == a)
    3647                 :            :         {
    3648                 :          0 :           next_cp = cp->next_first_allocno_copy;
    3649                 :          0 :           another_a = cp->second;
    3650                 :            :         }
    3651                 :          0 :       else if (cp->second == a)
    3652                 :            :         {
    3653                 :          0 :           next_cp = cp->next_second_allocno_copy;
    3654                 :          0 :           another_a = cp->first;
    3655                 :            :         }
    3656                 :            :       else
    3657                 :          0 :         gcc_unreachable ();
    3658                 :          0 :       if (! ira_reg_classes_intersect_p[aclass][ALLOCNO_CLASS (another_a)]
    3659                 :          0 :           || ! ALLOCNO_ASSIGNED_P (another_a)
    3660                 :          0 :           || (hard_regno = ALLOCNO_HARD_REGNO (another_a)) < 0)
    3661                 :          0 :         continue;
    3662                 :          0 :       rclass = REGNO_REG_CLASS (hard_regno);
    3663                 :          0 :       i = ira_class_hard_reg_index[aclass][hard_regno];
    3664                 :          0 :       if (i < 0)
    3665                 :          0 :         continue;
    3666                 :          0 :       cost = (cp->first == a
    3667                 :          0 :               ? ira_register_move_cost[mode][rclass][aclass]
    3668                 :          0 :               : ira_register_move_cost[mode][aclass][rclass]);
    3669                 :          0 :       ira_allocate_and_set_or_copy_costs
    3670                 :          0 :         (&ALLOCNO_UPDATED_HARD_REG_COSTS (a), aclass, ALLOCNO_CLASS_COST (a),
    3671                 :            :          ALLOCNO_HARD_REG_COSTS (a));
    3672                 :          0 :       ira_allocate_and_set_or_copy_costs
    3673                 :          0 :         (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a),
    3674                 :            :          aclass, 0, ALLOCNO_CONFLICT_HARD_REG_COSTS (a));
    3675                 :          0 :       ALLOCNO_UPDATED_HARD_REG_COSTS (a)[i] -= cp->freq * cost;
    3676                 :          0 :       ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a)[i] -= cp->freq * cost;
    3677                 :            :     }
    3678                 :            : }
    3679                 :            : 
    3680                 :            : /* Try to assign hard registers to the unassigned allocnos and
    3681                 :            :    allocnos conflicting with them or conflicting with allocnos whose
    3682                 :            :    regno >= START_REGNO.  The function is called after ira_flattening,
    3683                 :            :    so more allocnos (including ones created in ira-emit.c) will have a
    3684                 :            :    chance to get a hard register.  We use simple assignment algorithm
    3685                 :            :    based on priorities.  */
    3686                 :            : void
    3687                 :          0 : ira_reassign_conflict_allocnos (int start_regno)
    3688                 :            : {
    3689                 :          0 :   int i, allocnos_to_color_num;
    3690                 :          0 :   ira_allocno_t a;
    3691                 :          0 :   enum reg_class aclass;
    3692                 :          0 :   bitmap allocnos_to_color;
    3693                 :          0 :   ira_allocno_iterator ai;
    3694                 :            : 
    3695                 :          0 :   allocnos_to_color = ira_allocate_bitmap ();
    3696                 :          0 :   allocnos_to_color_num = 0;
    3697                 :          0 :   FOR_EACH_ALLOCNO (a, ai)
    3698                 :            :     {
    3699                 :          0 :       int n = ALLOCNO_NUM_OBJECTS (a);
    3700                 :            : 
    3701                 :          0 :       if (! ALLOCNO_ASSIGNED_P (a)
    3702                 :          0 :           && ! bitmap_bit_p (allocnos_to_color, ALLOCNO_NUM (a)))
    3703                 :            :         {
    3704                 :          0 :           if (ALLOCNO_CLASS (a) != NO_REGS)
    3705                 :          0 :             sorted_allocnos[allocnos_to_color_num++] = a;
    3706                 :            :           else
    3707                 :            :             {
    3708                 :          0 :               ALLOCNO_ASSIGNED_P (a) = true;
    3709                 :          0 :               ALLOCNO_HARD_REGNO (a) = -1;
    3710                 :          0 :               ira_assert (ALLOCNO_UPDATED_HARD_REG_COSTS (a) == NULL);
    3711                 :          0 :               ira_assert (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) == NULL);
    3712                 :            :             }
    3713                 :          0 :           bitmap_set_bit (allocnos_to_color, ALLOCNO_NUM (a));
    3714                 :            :         }
    3715                 :          0 :       if (ALLOCNO_REGNO (a) < start_regno
    3716                 :          0 :           || (aclass = ALLOCNO_CLASS (a)) == NO_REGS)
    3717                 :          0 :         continue;
    3718                 :          0 :       for (i = 0; i < n; i++)
    3719                 :            :         {
    3720                 :          0 :           ira_object_t obj = ALLOCNO_OBJECT (a, i);
    3721                 :          0 :           ira_object_t conflict_obj;
    3722                 :          0 :           ira_object_conflict_iterator oci;
    3723                 :            : 
    3724                 :          0 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    3725                 :            :             {
    3726                 :          0 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    3727                 :            : 
    3728                 :          0 :               ira_assert (ira_reg_classes_intersect_p
    3729                 :            :                           [aclass][ALLOCNO_CLASS (conflict_a)]);
    3730                 :          0 :               if (!bitmap_set_bit (allocnos_to_color, ALLOCNO_NUM (conflict_a)))
    3731                 :          0 :                 continue;
    3732                 :          0 :               sorted_allocnos[allocnos_to_color_num++] = conflict_a;
    3733                 :            :             }
    3734                 :            :         }
    3735                 :            :     }
    3736                 :          0 :   ira_free_bitmap (allocnos_to_color);
    3737                 :          0 :   if (allocnos_to_color_num > 1)
    3738                 :            :     {
    3739                 :          0 :       setup_allocno_priorities (sorted_allocnos, allocnos_to_color_num);
    3740                 :          0 :       qsort (sorted_allocnos, allocnos_to_color_num, sizeof (ira_allocno_t),
    3741                 :            :              allocno_priority_compare_func);
    3742                 :            :     }
    3743                 :          0 :   for (i = 0; i < allocnos_to_color_num; i++)
    3744                 :            :     {
    3745                 :          0 :       a = sorted_allocnos[i];
    3746                 :          0 :       ALLOCNO_ASSIGNED_P (a) = false;
    3747                 :          0 :       update_curr_costs (a);
    3748                 :            :     }
    3749                 :          0 :   for (i = 0; i < allocnos_to_color_num; i++)
    3750                 :            :     {
    3751                 :          0 :       a = sorted_allocnos[i];
    3752                 :          0 :       if (assign_hard_reg (a, true))
    3753                 :            :         {
    3754                 :          0 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3755                 :          0 :             fprintf
    3756                 :          0 :               (ira_dump_file,
    3757                 :            :                "      Secondary allocation: assign hard reg %d to reg %d\n",
    3758                 :          0 :                ALLOCNO_HARD_REGNO (a), ALLOCNO_REGNO (a));
    3759                 :            :         }
    3760                 :            :     }
    3761                 :          0 : }
    3762                 :            : 
    3763                 :            : 
    3764                 :            : 
    3765                 :            : /* This page contains functions used to find conflicts using allocno
    3766                 :            :    live ranges.  */
    3767                 :            : 
    3768                 :            : #ifdef ENABLE_IRA_CHECKING
    3769                 :            : 
    3770                 :            : /* Return TRUE if live ranges of pseudo-registers REGNO1 and REGNO2
    3771                 :            :    intersect.  This should be used when there is only one region.
    3772                 :            :    Currently this is used during reload.  */
    3773                 :            : static bool
    3774                 :          0 : conflict_by_live_ranges_p (int regno1, int regno2)
    3775                 :            : {
    3776                 :          0 :   ira_allocno_t a1, a2;
    3777                 :            : 
    3778                 :          0 :   ira_assert (regno1 >= FIRST_PSEUDO_REGISTER
    3779                 :            :               && regno2 >= FIRST_PSEUDO_REGISTER);
    3780                 :            :   /* Reg info calculated by dataflow infrastructure can be different
    3781                 :            :      from one calculated by regclass.  */
    3782                 :          0 :   if ((a1 = ira_loop_tree_root->regno_allocno_map[regno1]) == NULL
    3783                 :          0 :       || (a2 = ira_loop_tree_root->regno_allocno_map[regno2]) == NULL)
    3784                 :            :     return false;
    3785                 :          0 :   return allocnos_conflict_by_live_ranges_p (a1, a2);
    3786                 :            : }
    3787                 :            : 
    3788                 :            : #endif
    3789                 :            : 
    3790                 :            : 
    3791                 :            : 
    3792                 :            : /* This page contains code to coalesce memory stack slots used by
    3793                 :            :    spilled allocnos.  This results in smaller stack frame, better data
    3794                 :            :    locality, and in smaller code for some architectures like
    3795                 :            :    x86/x86_64 where insn size depends on address displacement value.
    3796                 :            :    On the other hand, it can worsen insn scheduling after the RA but
    3797                 :            :    in practice it is less important than smaller stack frames.  */
    3798                 :            : 
    3799                 :            : /* TRUE if we coalesced some allocnos.  In other words, if we got
    3800                 :            :    loops formed by members first_coalesced_allocno and
    3801                 :            :    next_coalesced_allocno containing more one allocno.  */
    3802                 :            : static bool allocno_coalesced_p;
    3803                 :            : 
    3804                 :            : /* Bitmap used to prevent a repeated allocno processing because of
    3805                 :            :    coalescing.  */
    3806                 :            : static bitmap processed_coalesced_allocno_bitmap;
    3807                 :            : 
    3808                 :            : /* See below.  */
    3809                 :            : typedef struct coalesce_data *coalesce_data_t;
    3810                 :            : 
    3811                 :            : /* To decrease footprint of ira_allocno structure we store all data
    3812                 :            :    needed only for coalescing in the following structure.  */
    3813                 :            : struct coalesce_data
    3814                 :            : {
    3815                 :            :   /* Coalesced allocnos form a cyclic list.  One allocno given by
    3816                 :            :      FIRST represents all coalesced allocnos.  The
    3817                 :            :      list is chained by NEXT.  */
    3818                 :            :   ira_allocno_t first;
    3819                 :            :   ira_allocno_t next;
    3820                 :            :   int temp;
    3821                 :            : };
    3822                 :            : 
    3823                 :            : /* Container for storing allocno data concerning coalescing.  */
    3824                 :            : static coalesce_data_t allocno_coalesce_data;
    3825                 :            : 
    3826                 :            : /* Macro to access the data concerning coalescing.  */
    3827                 :            : #define ALLOCNO_COALESCE_DATA(a) ((coalesce_data_t) ALLOCNO_ADD_DATA (a))
    3828                 :            : 
    3829                 :            : /* Merge two sets of coalesced allocnos given correspondingly by
    3830                 :            :    allocnos A1 and A2 (more accurately merging A2 set into A1
    3831                 :            :    set).  */
    3832                 :            : static void
    3833                 :          0 : merge_allocnos (ira_allocno_t a1, ira_allocno_t a2)
    3834                 :            : {
    3835                 :          0 :   ira_allocno_t a, first, last, next;
    3836                 :            : 
    3837                 :          0 :   first = ALLOCNO_COALESCE_DATA (a1)->first;
    3838                 :          0 :   a = ALLOCNO_COALESCE_DATA (a2)->first;
    3839                 :          0 :   if (first == a)
    3840                 :            :     return;
    3841                 :          0 :   for (last = a2, a = ALLOCNO_COALESCE_DATA (a2)->next;;
    3842                 :          0 :        a = ALLOCNO_COALESCE_DATA (a)->next)
    3843                 :            :     {
    3844                 :          0 :       ALLOCNO_COALESCE_DATA (a)->first = first;
    3845                 :          0 :       if (a == a2)
    3846                 :            :         break;
    3847                 :          0 :       last = a;
    3848                 :            :     }
    3849                 :          0 :   next = allocno_coalesce_data[ALLOCNO_NUM (first)].next;
    3850                 :          0 :   allocno_coalesce_data[ALLOCNO_NUM (first)].next = a2;
    3851                 :          0 :   allocno_coalesce_data[ALLOCNO_NUM (last)].next = next;
    3852                 :            : }
    3853                 :            : 
    3854                 :            : /* Return TRUE if there are conflicting allocnos from two sets of
    3855                 :            :    coalesced allocnos given correspondingly by allocnos A1 and A2.  We
    3856                 :            :    use live ranges to find conflicts because conflicts are represented
    3857                 :            :    only for allocnos of the same allocno class and during the reload
    3858                 :            :    pass we coalesce allocnos for sharing stack memory slots.  */
    3859                 :            : static bool
    3860                 :          0 : coalesced_allocno_conflict_p (ira_allocno_t a1, ira_allocno_t a2)
    3861                 :            : {
    3862                 :          0 :   ira_allocno_t a, conflict_a;
    3863                 :            : 
    3864                 :          0 :   if (allocno_coalesced_p)
    3865                 :            :     {
    3866                 :          0 :       bitmap_clear (processed_coalesced_allocno_bitmap);
    3867                 :          0 :       for (a = ALLOCNO_COALESCE_DATA (a1)->next;;
    3868                 :          0 :            a = ALLOCNO_COALESCE_DATA (a)->next)
    3869                 :            :         {
    3870                 :          0 :           bitmap_set_bit (processed_coalesced_allocno_bitmap, ALLOCNO_NUM (a));
    3871                 :          0 :           if (a == a1)
    3872                 :            :             break;
    3873                 :            :         }
    3874                 :            :     }
    3875                 :          0 :   for (a = ALLOCNO_COALESCE_DATA (a2)->next;;
    3876                 :          0 :        a = ALLOCNO_COALESCE_DATA (a)->next)
    3877                 :            :     {
    3878                 :          0 :       for (conflict_a = ALLOCNO_COALESCE_DATA (a1)->next;;
    3879                 :          0 :            conflict_a = ALLOCNO_COALESCE_DATA (conflict_a)->next)
    3880                 :            :         {
    3881                 :          0 :           if (allocnos_conflict_by_live_ranges_p (a, conflict_a))
    3882                 :            :             return true;
    3883                 :          0 :           if (conflict_a == a1)
    3884                 :            :             break;
    3885                 :            :         }
    3886                 :          0 :       if (a == a2)
    3887                 :            :         break;
    3888                 :            :     }
    3889                 :            :   return false;
    3890                 :            : }
    3891                 :            : 
    3892                 :            : /* The major function for aggressive allocno coalescing.  We coalesce
    3893                 :            :    only spilled allocnos.  If some allocnos have been coalesced, we
    3894                 :            :    set up flag allocno_coalesced_p.  */
    3895                 :            : static void
    3896                 :          0 : coalesce_allocnos (void)
    3897                 :            : {
    3898                 :          0 :   ira_allocno_t a;
    3899                 :          0 :   ira_copy_t cp, next_cp;
    3900                 :          0 :   unsigned int j;
    3901                 :          0 :   int i, n, cp_num, regno;
    3902                 :          0 :   bitmap_iterator bi;
    3903                 :            : 
    3904                 :          0 :   cp_num = 0;
    3905                 :            :   /* Collect copies.  */
    3906                 :          0 :   EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, j, bi)
    3907                 :            :     {
    3908                 :          0 :       a = ira_allocnos[j];
    3909                 :          0 :       regno = ALLOCNO_REGNO (a);
    3910                 :          0 :       if (! ALLOCNO_ASSIGNED_P (a) || ALLOCNO_HARD_REGNO (a) >= 0
    3911                 :          0 :           || ira_equiv_no_lvalue_p (regno))
    3912                 :          0 :         continue;
    3913                 :          0 :       for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    3914                 :            :         {
    3915                 :          0 :           if (cp->first == a)
    3916                 :            :             {
    3917                 :          0 :               next_cp = cp->next_first_allocno_copy;
    3918                 :          0 :               regno = ALLOCNO_REGNO (cp->second);
    3919                 :            :               /* For priority coloring we coalesce allocnos only with
    3920                 :            :                  the same allocno class not with intersected allocno
    3921                 :            :                  classes as it were possible.  It is done for
    3922                 :            :                  simplicity.  */
    3923                 :          0 :               if ((cp->insn != NULL || cp->constraint_p)
    3924                 :          0 :                   && ALLOCNO_ASSIGNED_P (cp->second)
    3925                 :          0 :                   && ALLOCNO_HARD_REGNO (cp->second) < 0
    3926                 :          0 :                   && ! ira_equiv_no_lvalue_p (regno))
    3927                 :          0 :                 sorted_copies[cp_num++] = cp;
    3928                 :            :             }
    3929                 :          0 :           else if (cp->second == a)
    3930                 :          0 :             next_cp = cp->next_second_allocno_copy;
    3931                 :            :           else
    3932                 :          0 :             gcc_unreachable ();
    3933                 :            :         }
    3934                 :            :     }
    3935                 :          0 :   qsort (sorted_copies, cp_num, sizeof (ira_copy_t), copy_freq_compare_func);
    3936                 :            :   /* Coalesced copies, most frequently executed first.  */
    3937                 :          0 :   for (; cp_num != 0;)
    3938                 :            :     {
    3939                 :          0 :       for (i = 0; i < cp_num; i++)
    3940                 :            :         {
    3941                 :          0 :           cp = sorted_copies[i];
    3942                 :          0 :           if (! coalesced_allocno_conflict_p (cp->first, cp->second))
    3943                 :            :             {
    3944                 :          0 :               allocno_coalesced_p = true;
    3945                 :          0 :               if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    3946                 :          0 :                 fprintf
    3947                 :          0 :                   (ira_dump_file,
    3948                 :            :                    "      Coalescing copy %d:a%dr%d-a%dr%d (freq=%d)\n",
    3949                 :          0 :                    cp->num, ALLOCNO_NUM (cp->first), ALLOCNO_REGNO (cp->first),
    3950                 :          0 :                    ALLOCNO_NUM (cp->second), ALLOCNO_REGNO (cp->second),
    3951                 :            :                    cp->freq);
    3952                 :          0 :               merge_allocnos (cp->first, cp->second);
    3953                 :          0 :               i++;
    3954                 :          0 :               break;
    3955                 :            :             }
    3956                 :            :         }
    3957                 :            :       /* Collect the rest of copies.  */
    3958                 :          0 :       for (n = 0; i < cp_num; i++)
    3959                 :            :         {
    3960                 :          0 :           cp = sorted_copies[i];
    3961                 :          0 :           if (allocno_coalesce_data[ALLOCNO_NUM (cp->first)].first
    3962                 :          0 :               != allocno_coalesce_data[ALLOCNO_NUM (cp->second)].first)
    3963                 :          0 :             sorted_copies[n++] = cp;
    3964                 :            :         }
    3965                 :            :       cp_num = n;
    3966                 :            :     }
    3967                 :          0 : }
    3968                 :            : 
    3969                 :            : /* Usage cost and order number of coalesced allocno set to which
    3970                 :            :    given pseudo register belongs to.  */
    3971                 :            : static int *regno_coalesced_allocno_cost;
    3972                 :            : static int *regno_coalesced_allocno_num;
    3973                 :            : 
    3974                 :            : /* Sort pseudos according frequencies of coalesced allocno sets they
    3975                 :            :    belong to (putting most frequently ones first), and according to
    3976                 :            :    coalesced allocno set order numbers.  */
    3977                 :            : static int
    3978                 :          0 : coalesced_pseudo_reg_freq_compare (const void *v1p, const void *v2p)
    3979                 :            : {
    3980                 :          0 :   const int regno1 = *(const int *) v1p;
    3981                 :          0 :   const int regno2 = *(const int *) v2p;
    3982                 :          0 :   int diff;
    3983                 :            : 
    3984                 :          0 :   if ((diff = (regno_coalesced_allocno_cost[regno2]
    3985                 :          0 :                - regno_coalesced_allocno_cost[regno1])) != 0)
    3986                 :            :     return diff;
    3987                 :          0 :   if ((diff = (regno_coalesced_allocno_num[regno1]
    3988                 :          0 :                - regno_coalesced_allocno_num[regno2])) != 0)
    3989                 :            :     return diff;
    3990                 :          0 :   return regno1 - regno2;
    3991                 :            : }
    3992                 :            : 
    3993                 :            : /* Widest width in which each pseudo reg is referred to (via subreg).
    3994                 :            :    It is used for sorting pseudo registers.  */
    3995                 :            : static machine_mode *regno_max_ref_mode;
    3996                 :            : 
    3997                 :            : /* Sort pseudos according their slot numbers (putting ones with
    3998                 :            :   smaller numbers first, or last when the frame pointer is not
    3999                 :            :   needed).  */
    4000                 :            : static int
    4001                 :          0 : coalesced_pseudo_reg_slot_compare (const void *v1p, const void *v2p)
    4002                 :            : {
    4003                 :          0 :   const int regno1 = *(const int *) v1p;
    4004                 :          0 :   const int regno2 = *(const int *) v2p;
    4005                 :          0 :   ira_allocno_t a1 = ira_regno_allocno_map[regno1];
    4006                 :          0 :   ira_allocno_t a2 = ira_regno_allocno_map[regno2];
    4007                 :          0 :   int diff, slot_num1, slot_num2;
    4008                 :          0 :   machine_mode mode1, mode2;
    4009                 :            : 
    4010                 :          0 :   if (a1 == NULL || ALLOCNO_HARD_REGNO (a1) >= 0)
    4011                 :            :     {
    4012                 :          0 :       if (a2 == NULL || ALLOCNO_HARD_REGNO (a2) >= 0)
    4013                 :          0 :         return regno1 - regno2;
    4014                 :            :       return 1;
    4015                 :            :     }
    4016                 :          0 :   else if (a2 == NULL || ALLOCNO_HARD_REGNO (a2) >= 0)
    4017                 :            :     return -1;
    4018                 :          0 :   slot_num1 = -ALLOCNO_HARD_REGNO (a1);
    4019                 :          0 :   slot_num2 = -ALLOCNO_HARD_REGNO (a2);
    4020                 :          0 :   if ((diff = slot_num1 - slot_num2) != 0)
    4021                 :          0 :     return (frame_pointer_needed
    4022                 :          0 :             || (!FRAME_GROWS_DOWNWARD) == STACK_GROWS_DOWNWARD ? diff : -diff);
    4023                 :          0 :   mode1 = wider_subreg_mode (PSEUDO_REGNO_MODE (regno1),
    4024                 :          0 :                              regno_max_ref_mode[regno1]);
    4025                 :          0 :   mode2 = wider_subreg_mode (PSEUDO_REGNO_MODE (regno2),
    4026                 :          0 :                              regno_max_ref_mode[regno2]);
    4027                 :          0 :   if ((diff = compare_sizes_for_sort (GET_MODE_SIZE (mode2),
    4028                 :          0 :                                       GET_MODE_SIZE (mode1))) != 0)
    4029                 :          0 :     return diff;
    4030                 :          0 :   return regno1 - regno2;
    4031                 :            : }
    4032                 :            : 
    4033                 :            : /* Setup REGNO_COALESCED_ALLOCNO_COST and REGNO_COALESCED_ALLOCNO_NUM
    4034                 :            :    for coalesced allocno sets containing allocnos with their regnos
    4035                 :            :    given in array PSEUDO_REGNOS of length N.  */
    4036                 :            : static void
    4037                 :          0 : setup_coalesced_allocno_costs_and_nums (int *pseudo_regnos, int n)
    4038                 :            : {
    4039                 :          0 :   int i, num, regno, cost;
    4040                 :          0 :   ira_allocno_t allocno, a;
    4041                 :            : 
    4042                 :          0 :   for (num = i = 0; i < n; i++)
    4043                 :            :     {
    4044                 :          0 :       regno = pseudo_regnos[i];
    4045                 :          0 :       allocno = ira_regno_allocno_map[regno];
    4046                 :          0 :       if (allocno == NULL)
    4047                 :            :         {
    4048                 :          0 :           regno_coalesced_allocno_cost[regno] = 0;
    4049                 :          0 :           regno_coalesced_allocno_num[regno] = ++num;
    4050                 :          0 :           continue;
    4051                 :            :         }
    4052                 :          0 :       if (ALLOCNO_COALESCE_DATA (allocno)->first != allocno)
    4053                 :          0 :         continue;
    4054                 :          0 :       num++;
    4055                 :          0 :       for (cost = 0, a = ALLOCNO_COALESCE_DATA (allocno)->next;;
    4056                 :          0 :            a = ALLOCNO_COALESCE_DATA (a)->next)
    4057                 :            :         {
    4058                 :          0 :           cost += ALLOCNO_FREQ (a);
    4059                 :          0 :           if (a == allocno)
    4060                 :            :             break;
    4061                 :            :         }
    4062                 :          0 :       for (a = ALLOCNO_COALESCE_DATA (allocno)->next;;
    4063                 :          0 :            a = ALLOCNO_COALESCE_DATA (a)->next)
    4064                 :            :         {
    4065                 :          0 :           regno_coalesced_allocno_num[ALLOCNO_REGNO (a)] = num;
    4066                 :          0 :           regno_coalesced_allocno_cost[ALLOCNO_REGNO (a)] = cost;
    4067                 :          0 :           if (a == allocno)
    4068                 :            :             break;
    4069                 :            :         }
    4070                 :            :     }
    4071                 :          0 : }
    4072                 :            : 
    4073                 :            : /* Collect spilled allocnos representing coalesced allocno sets (the
    4074                 :            :    first coalesced allocno).  The collected allocnos are returned
    4075                 :            :    through array SPILLED_COALESCED_ALLOCNOS.  The function returns the
    4076                 :            :    number of the collected allocnos.  The allocnos are given by their
    4077                 :            :    regnos in array PSEUDO_REGNOS of length N.  */
    4078                 :            : static int
    4079                 :          0 : collect_spilled_coalesced_allocnos (int *pseudo_regnos, int n,
    4080                 :            :                                     ira_allocno_t *spilled_coalesced_allocnos)
    4081                 :            : {
    4082                 :          0 :   int i, num, regno;
    4083                 :          0 :   ira_allocno_t allocno;
    4084                 :            : 
    4085                 :          0 :   for (num = i = 0; i < n; i++)
    4086                 :            :     {
    4087                 :          0 :       regno = pseudo_regnos[i];
    4088                 :          0 :       allocno = ira_regno_allocno_map[regno];
    4089                 :          0 :       if (allocno == NULL || ALLOCNO_HARD_REGNO (allocno) >= 0
    4090                 :          0 :           || ALLOCNO_COALESCE_DATA (allocno)->first != allocno)
    4091                 :          0 :         continue;
    4092                 :          0 :       spilled_coalesced_allocnos[num++] = allocno;
    4093                 :            :     }
    4094                 :          0 :   return num;
    4095                 :            : }
    4096                 :            : 
    4097                 :            : /* Array of live ranges of size IRA_ALLOCNOS_NUM.  Live range for
    4098                 :            :    given slot contains live ranges of coalesced allocnos assigned to
    4099                 :            :    given slot.  */
    4100                 :            : static live_range_t *slot_coalesced_allocnos_live_ranges;
    4101                 :            : 
    4102                 :            : /* Return TRUE if coalesced allocnos represented by ALLOCNO has live
    4103                 :            :    ranges intersected with live ranges of coalesced allocnos assigned
    4104                 :            :    to slot with number N.  */
    4105                 :            : static bool
    4106                 :          0 : slot_coalesced_allocno_live_ranges_intersect_p (ira_allocno_t allocno, int n)
    4107                 :            : {
    4108                 :          0 :   ira_allocno_t a;
    4109                 :            : 
    4110                 :          0 :   for (a = ALLOCNO_COALESCE_DATA (allocno)->next;;
    4111                 :          0 :        a = ALLOCNO_COALESCE_DATA (a)->next)
    4112                 :            :     {
    4113                 :          0 :       int i;
    4114                 :          0 :       int nr = ALLOCNO_NUM_OBJECTS (a);
    4115                 :          0 :       gcc_assert (ALLOCNO_CAP_MEMBER (a) == NULL);
    4116                 :          0 :       for (i = 0; i < nr; i++)
    4117                 :            :         {
    4118                 :          0 :           ira_object_t obj = ALLOCNO_OBJECT (a, i);
    4119                 :            : 
    4120                 :          0 :           if (ira_live_ranges_intersect_p
    4121                 :          0 :               (slot_coalesced_allocnos_live_ranges[n],
    4122                 :            :                OBJECT_LIVE_RANGES (obj)))
    4123                 :            :             return true;
    4124                 :            :         }
    4125                 :          0 :       if (a == allocno)
    4126                 :            :         break;
    4127                 :          0 :     }
    4128                 :            :   return false;
    4129                 :            : }
    4130                 :            : 
    4131                 :            : /* Update live ranges of slot to which coalesced allocnos represented
    4132                 :            :    by ALLOCNO were assigned.  */
    4133                 :            : static void
    4134                 :          0 : setup_slot_coalesced_allocno_live_ranges (ira_allocno_t allocno)
    4135                 :            : {
    4136                 :          0 :   int i, n;
    4137                 :          0 :   ira_allocno_t a;
    4138                 :          0 :   live_range_t r;
    4139                 :            : 
    4140                 :          0 :   n = ALLOCNO_COALESCE_DATA (allocno)->temp;
    4141                 :          0 :   for (a = ALLOCNO_COALESCE_DATA (allocno)->next;;
    4142                 :          0 :        a = ALLOCNO_COALESCE_DATA (a)->next)
    4143                 :            :     {
    4144                 :          0 :       int nr = ALLOCNO_NUM_OBJECTS (a);
    4145                 :          0 :       gcc_assert (ALLOCNO_CAP_MEMBER (a) == NULL);
    4146                 :          0 :       for (i = 0; i < nr; i++)
    4147                 :            :         {
    4148                 :          0 :           ira_object_t obj = ALLOCNO_OBJECT (a, i);
    4149                 :            : 
    4150                 :          0 :           r = ira_copy_live_range_list (OBJECT_LIVE_RANGES (obj));
    4151                 :          0 :           slot_coalesced_allocnos_live_ranges[n]
    4152                 :          0 :             = ira_merge_live_ranges
    4153                 :          0 :               (slot_coalesced_allocnos_live_ranges[n], r);
    4154                 :            :         }
    4155                 :          0 :       if (a == allocno)
    4156                 :            :         break;
    4157                 :          0 :     }
    4158                 :          0 : }
    4159                 :            : 
    4160                 :            : /* We have coalesced allocnos involving in copies.  Coalesce allocnos
    4161                 :            :    further in order to share the same memory stack slot.  Allocnos
    4162                 :            :    representing sets of allocnos coalesced before the call are given
    4163                 :            :    in array SPILLED_COALESCED_ALLOCNOS of length NUM.  Return TRUE if
    4164                 :            :    some allocnos were coalesced in the function.  */
    4165                 :            : static bool
    4166                 :          0 : coalesce_spill_slots (ira_allocno_t *spilled_coalesced_allocnos, int num)
    4167                 :            : {
    4168                 :          0 :   int i, j, n, last_coalesced_allocno_num;
    4169                 :          0 :   ira_allocno_t allocno, a;
    4170                 :          0 :   bool merged_p = false;
    4171                 :          0 :   bitmap set_jump_crosses = regstat_get_setjmp_crosses ();
    4172                 :            : 
    4173                 :          0 :   slot_coalesced_allocnos_live_ranges
    4174                 :          0 :     = (live_range_t *) ira_allocate (sizeof (live_range_t) * ira_allocnos_num);
    4175                 :          0 :   memset (slot_coalesced_allocnos_live_ranges, 0,
    4176                 :          0 :           sizeof (live_range_t) * ira_allocnos_num);
    4177                 :          0 :   last_coalesced_allocno_num = 0;
    4178                 :            :   /* Coalesce non-conflicting spilled allocnos preferring most
    4179                 :            :      frequently used.  */
    4180                 :          0 :   for (i = 0; i < num; i++)
    4181                 :            :     {
    4182                 :          0 :       allocno = spilled_coalesced_allocnos[i];
    4183                 :          0 :       if (ALLOCNO_COALESCE_DATA (allocno)->first != allocno
    4184                 :          0 :           || bitmap_bit_p (set_jump_crosses, ALLOCNO_REGNO (allocno))
    4185                 :          0 :           || ira_equiv_no_lvalue_p (ALLOCNO_REGNO (allocno)))
    4186                 :          0 :         continue;
    4187                 :          0 :       for (j = 0; j < i; j++)
    4188                 :            :         {
    4189                 :          0 :           a = spilled_coalesced_allocnos[j];
    4190                 :          0 :           n = ALLOCNO_COALESCE_DATA (a)->temp;
    4191                 :          0 :           if (ALLOCNO_COALESCE_DATA (a)->first == a
    4192                 :          0 :               && ! bitmap_bit_p (set_jump_crosses, ALLOCNO_REGNO (a))
    4193                 :          0 :               && ! ira_equiv_no_lvalue_p (ALLOCNO_REGNO (a))
    4194                 :          0 :               && ! slot_coalesced_allocno_live_ranges_intersect_p (allocno, n))
    4195                 :            :             break;
    4196                 :            :         }
    4197                 :          0 :       if (j >= i)
    4198                 :            :         {
    4199                 :            :           /* No coalescing: set up number for coalesced allocnos
    4200                 :            :              represented by ALLOCNO.  */
    4201                 :          0 :           ALLOCNO_COALESCE_DATA (allocno)->temp = last_coalesced_allocno_num++;
    4202                 :          0 :           setup_slot_coalesced_allocno_live_ranges (allocno);
    4203                 :            :         }
    4204                 :            :       else
    4205                 :            :         {
    4206                 :          0 :           allocno_coalesced_p = true;
    4207                 :          0 :           merged_p = true;
    4208                 :          0 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4209                 :          0 :             fprintf (ira_dump_file,
    4210                 :            :                      "      Coalescing spilled allocnos a%dr%d->a%dr%d\n",
    4211                 :            :                      ALLOCNO_NUM (allocno), ALLOCNO_REGNO (allocno),
    4212                 :            :                      ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
    4213                 :          0 :           ALLOCNO_COALESCE_DATA (allocno)->temp
    4214                 :          0 :             = ALLOCNO_COALESCE_DATA (a)->temp;
    4215                 :          0 :           setup_slot_coalesced_allocno_live_ranges (allocno);
    4216                 :          0 :           merge_allocnos (a, allocno);
    4217                 :          0 :           ira_assert (ALLOCNO_COALESCE_DATA (a)->first == a);
    4218                 :            :         }
    4219                 :            :     }
    4220                 :          0 :   for (i = 0; i < ira_allocnos_num; i++)
    4221                 :          0 :     ira_finish_live_range_list (slot_coalesced_allocnos_live_ranges[i]);
    4222                 :          0 :   ira_free (slot_coalesced_allocnos_live_ranges);
    4223                 :          0 :   return merged_p;
    4224                 :            : }
    4225                 :            : 
    4226                 :            : /* Sort pseudo-register numbers in array PSEUDO_REGNOS of length N for
    4227                 :            :    subsequent assigning stack slots to them in the reload pass.  To do
    4228                 :            :    this we coalesce spilled allocnos first to decrease the number of
    4229                 :            :    memory-memory move insns.  This function is called by the
    4230                 :            :    reload.  */
    4231                 :            : void
    4232                 :          0 : ira_sort_regnos_for_alter_reg (int *pseudo_regnos, int n,
    4233                 :            :                                machine_mode *reg_max_ref_mode)
    4234                 :            : {
    4235                 :          0 :   int max_regno = max_reg_num ();
    4236                 :          0 :   int i, regno, num, slot_num;
    4237                 :          0 :   ira_allocno_t allocno, a;
    4238                 :          0 :   ira_allocno_iterator ai;
    4239                 :          0 :   ira_allocno_t *spilled_coalesced_allocnos;
    4240                 :            : 
    4241                 :          0 :   ira_assert (! ira_use_lra_p);
    4242                 :            : 
    4243                 :            :   /* Set up allocnos can be coalesced.  */
    4244                 :          0 :   coloring_allocno_bitmap = ira_allocate_bitmap ();
    4245                 :          0 :   for (i = 0; i < n; i++)
    4246                 :            :     {
    4247                 :          0 :       regno = pseudo_regnos[i];
    4248                 :          0 :       allocno = ira_regno_allocno_map[regno];
    4249                 :          0 :       if (allocno != NULL)
    4250                 :          0 :         bitmap_set_bit (coloring_allocno_bitmap, ALLOCNO_NUM (allocno));
    4251                 :            :     }
    4252                 :          0 :   allocno_coalesced_p = false;
    4253                 :          0 :   processed_coalesced_allocno_bitmap = ira_allocate_bitmap ();
    4254                 :          0 :   allocno_coalesce_data
    4255                 :          0 :     = (coalesce_data_t) ira_allocate (sizeof (struct coalesce_data)
    4256                 :          0 :                                       * ira_allocnos_num);
    4257                 :            :   /* Initialize coalesce data for allocnos.  */
    4258                 :          0 :   FOR_EACH_ALLOCNO (a, ai)
    4259                 :            :     {
    4260                 :          0 :       ALLOCNO_ADD_DATA (a) = allocno_coalesce_data + ALLOCNO_NUM (a);
    4261                 :          0 :       ALLOCNO_COALESCE_DATA (a)->first = a;
    4262                 :          0 :       ALLOCNO_COALESCE_DATA (a)->next = a;
    4263                 :            :     }
    4264                 :          0 :   coalesce_allocnos ();
    4265                 :          0 :   ira_free_bitmap (coloring_allocno_bitmap);
    4266                 :          0 :   regno_coalesced_allocno_cost
    4267                 :          0 :     = (int *) ira_allocate (max_regno * sizeof (int));
    4268                 :          0 :   regno_coalesced_allocno_num
    4269                 :          0 :     = (int *) ira_allocate (max_regno * sizeof (int));
    4270                 :          0 :   memset (regno_coalesced_allocno_num, 0, max_regno * sizeof (int));
    4271                 :          0 :   setup_coalesced_allocno_costs_and_nums (pseudo_regnos, n);
    4272                 :            :   /* Sort regnos according frequencies of the corresponding coalesced
    4273                 :            :      allocno sets.  */
    4274                 :          0 :   qsort (pseudo_regnos, n, sizeof (int), coalesced_pseudo_reg_freq_compare);
    4275                 :          0 :   spilled_coalesced_allocnos
    4276                 :          0 :     = (ira_allocno_t *) ira_allocate (ira_allocnos_num
    4277                 :            :                                       * sizeof (ira_allocno_t));
    4278                 :            :   /* Collect allocnos representing the spilled coalesced allocno
    4279                 :            :      sets.  */
    4280                 :          0 :   num = collect_spilled_coalesced_allocnos (pseudo_regnos, n,
    4281                 :            :                                             spilled_coalesced_allocnos);
    4282                 :          0 :   if (flag_ira_share_spill_slots
    4283                 :          0 :       && coalesce_spill_slots (spilled_coalesced_allocnos, num))
    4284                 :            :     {
    4285                 :          0 :       setup_coalesced_allocno_costs_and_nums (pseudo_regnos, n);
    4286                 :          0 :       qsort (pseudo_regnos, n, sizeof (int),
    4287                 :            :              coalesced_pseudo_reg_freq_compare);
    4288                 :          0 :       num = collect_spilled_coalesced_allocnos (pseudo_regnos, n,
    4289                 :            :                                                 spilled_coalesced_allocnos);
    4290                 :            :     }
    4291                 :          0 :   ira_free_bitmap (processed_coalesced_allocno_bitmap);
    4292                 :          0 :   allocno_coalesced_p = false;
    4293                 :            :   /* Assign stack slot numbers to spilled allocno sets, use smaller
    4294                 :            :      numbers for most frequently used coalesced allocnos.  -1 is
    4295                 :            :      reserved for dynamic search of stack slots for pseudos spilled by
    4296                 :            :      the reload.  */
    4297                 :          0 :   slot_num = 1;
    4298                 :          0 :   for (i = 0; i < num; i++)
    4299                 :            :     {
    4300                 :          0 :       allocno = spilled_coalesced_allocnos[i];
    4301                 :          0 :       if (ALLOCNO_COALESCE_DATA (allocno)->first != allocno
    4302                 :          0 :           || ALLOCNO_HARD_REGNO (allocno) >= 0
    4303                 :          0 :           || ira_equiv_no_lvalue_p (ALLOCNO_REGNO (allocno)))
    4304                 :          0 :         continue;
    4305                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4306                 :          0 :         fprintf (ira_dump_file, "      Slot %d (freq,size):", slot_num);
    4307                 :          0 :       slot_num++;
    4308                 :          0 :       for (a = ALLOCNO_COALESCE_DATA (allocno)->next;;
    4309                 :          0 :            a = ALLOCNO_COALESCE_DATA (a)->next)
    4310                 :            :         {
    4311                 :          0 :           ira_assert (ALLOCNO_HARD_REGNO (a) < 0);
    4312                 :          0 :           ALLOCNO_HARD_REGNO (a) = -slot_num;
    4313                 :          0 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4314                 :            :             {
    4315                 :          0 :               machine_mode mode = wider_subreg_mode
    4316                 :          0 :                 (PSEUDO_REGNO_MODE (ALLOCNO_REGNO (a)),
    4317                 :          0 :                  reg_max_ref_mode[ALLOCNO_REGNO (a)]);
    4318                 :          0 :               fprintf (ira_dump_file, " a%dr%d(%d,",
    4319                 :            :                        ALLOCNO_NUM (a), ALLOCNO_REGNO (a), ALLOCNO_FREQ (a));
    4320                 :          0 :               print_dec (GET_MODE_SIZE (mode), ira_dump_file, SIGNED);
    4321                 :          0 :               fprintf (ira_dump_file, ")\n");
    4322                 :            :             }
    4323                 :            : 
    4324                 :          0 :           if (a == allocno)
    4325                 :            :             break;
    4326                 :          0 :         }
    4327                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4328                 :          0 :         fprintf (ira_dump_file, "\n");
    4329                 :            :     }
    4330                 :          0 :   ira_spilled_reg_stack_slots_num = slot_num - 1;
    4331                 :          0 :   ira_free (spilled_coalesced_allocnos);
    4332                 :            :   /* Sort regnos according the slot numbers.  */
    4333                 :          0 :   regno_max_ref_mode = reg_max_ref_mode;
    4334                 :          0 :   qsort (pseudo_regnos, n, sizeof (int), coalesced_pseudo_reg_slot_compare);
    4335                 :          0 :   FOR_EACH_ALLOCNO (a, ai)
    4336                 :          0 :     ALLOCNO_ADD_DATA (a) = NULL;
    4337                 :          0 :   ira_free (allocno_coalesce_data);
    4338                 :          0 :   ira_free (regno_coalesced_allocno_num);
    4339                 :          0 :   ira_free (regno_coalesced_allocno_cost);
    4340                 :          0 : }
    4341                 :            : 
    4342                 :            : 
    4343                 :            : 
    4344                 :            : /* This page contains code used by the reload pass to improve the
    4345                 :            :    final code.  */
    4346                 :            : 
    4347                 :            : /* The function is called from reload to mark changes in the
    4348                 :            :    allocation of REGNO made by the reload.  Remember that reg_renumber
    4349                 :            :    reflects the change result.  */
    4350                 :            : void
    4351                 :          0 : ira_mark_allocation_change (int regno)
    4352                 :            : {
    4353                 :          0 :   ira_allocno_t a = ira_regno_allocno_map[regno];
    4354                 :          0 :   int old_hard_regno, hard_regno, cost;
    4355                 :          0 :   enum reg_class aclass = ALLOCNO_CLASS (a);
    4356                 :            : 
    4357                 :          0 :   ira_assert (a != NULL);
    4358                 :          0 :   hard_regno = reg_renumber[regno];
    4359                 :          0 :   if ((old_hard_regno = ALLOCNO_HARD_REGNO (a)) == hard_regno)
    4360                 :            :     return;
    4361                 :          0 :   if (old_hard_regno < 0)
    4362                 :          0 :     cost = -ALLOCNO_MEMORY_COST (a);
    4363                 :            :   else
    4364                 :            :     {
    4365                 :          0 :       ira_assert (ira_class_hard_reg_index[aclass][old_hard_regno] >= 0);
    4366                 :          0 :       cost = -(ALLOCNO_HARD_REG_COSTS (a) == NULL
    4367                 :          0 :                ? ALLOCNO_CLASS_COST (a)
    4368                 :            :                : ALLOCNO_HARD_REG_COSTS (a)
    4369                 :          0 :                  [ira_class_hard_reg_index[aclass][old_hard_regno]]);
    4370                 :          0 :       update_costs_from_copies (a, false, false);
    4371                 :            :     }
    4372                 :          0 :   ira_overall_cost -= cost;
    4373                 :          0 :   ALLOCNO_HARD_REGNO (a) = hard_regno;
    4374                 :          0 :   if (hard_regno < 0)
    4375                 :            :     {
    4376                 :          0 :       ALLOCNO_HARD_REGNO (a) = -1;
    4377                 :          0 :       cost += ALLOCNO_MEMORY_COST (a);
    4378                 :            :     }
    4379                 :          0 :   else if (ira_class_hard_reg_index[aclass][hard_regno] >= 0)
    4380                 :            :     {
    4381                 :          0 :       cost += (ALLOCNO_HARD_REG_COSTS (a) == NULL
    4382                 :          0 :                ? ALLOCNO_CLASS_COST (a)
    4383                 :            :                : ALLOCNO_HARD_REG_COSTS (a)
    4384                 :          0 :                  [ira_class_hard_reg_index[aclass][hard_regno]]);
    4385                 :          0 :       update_costs_from_copies (a, true, false);
    4386                 :            :     }
    4387                 :            :   else
    4388                 :            :     /* Reload changed class of the allocno.  */
    4389                 :            :     cost = 0;
    4390                 :          0 :   ira_overall_cost += cost;
    4391                 :            : }
    4392                 :            : 
    4393                 :            : /* This function is called when reload deletes memory-memory move.  In
    4394                 :            :    this case we marks that the allocation of the corresponding
    4395                 :            :    allocnos should be not changed in future.  Otherwise we risk to get
    4396                 :            :    a wrong code.  */
    4397                 :            : void
    4398                 :          0 : ira_mark_memory_move_deletion (int dst_regno, int src_regno)
    4399                 :            : {
    4400                 :          0 :   ira_allocno_t dst = ira_regno_allocno_map[dst_regno];
    4401                 :          0 :   ira_allocno_t src = ira_regno_allocno_map[src_regno];
    4402                 :            : 
    4403                 :          0 :   ira_assert (dst != NULL && src != NULL
    4404                 :            :               && ALLOCNO_HARD_REGNO (dst) < 0
    4405                 :            :               && ALLOCNO_HARD_REGNO (src) < 0);
    4406                 :          0 :   ALLOCNO_DONT_REASSIGN_P (dst) = true;
    4407                 :          0 :   ALLOCNO_DONT_REASSIGN_P (src) = true;
    4408                 :          0 : }
    4409                 :            : 
    4410                 :            : /* Try to assign a hard register (except for FORBIDDEN_REGS) to
    4411                 :            :    allocno A and return TRUE in the case of success.  */
    4412                 :            : static bool
    4413                 :          0 : allocno_reload_assign (ira_allocno_t a, HARD_REG_SET forbidden_regs)
    4414                 :            : {
    4415                 :          0 :   int hard_regno;
    4416                 :          0 :   enum reg_class aclass;
    4417                 :          0 :   int regno = ALLOCNO_REGNO (a);
    4418                 :          0 :   HARD_REG_SET saved[2];
    4419                 :          0 :   int i, n;
    4420                 :            : 
    4421                 :          0 :   n = ALLOCNO_NUM_OBJECTS (a);
    4422                 :          0 :   for (i = 0; i < n; i++)
    4423                 :            :     {
    4424                 :          0 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    4425                 :          0 :       saved[i] = OBJECT_TOTAL_CONFLICT_HARD_REGS (obj);
    4426                 :          0 :       OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= forbidden_regs;
    4427                 :          0 :       if (! flag_caller_saves && ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
    4428                 :          0 :         OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= ira_need_caller_save_regs (a);
    4429                 :            :     }
    4430                 :          0 :   ALLOCNO_ASSIGNED_P (a) = false;
    4431                 :          0 :   aclass = ALLOCNO_CLASS (a);
    4432                 :          0 :   update_curr_costs (a);
    4433                 :          0 :   assign_hard_reg (a, true);
    4434                 :          0 :   hard_regno = ALLOCNO_HARD_REGNO (a);
    4435                 :          0 :   reg_renumber[regno] = hard_regno;
    4436                 :          0 :   if (hard_regno < 0)
    4437                 :          0 :     ALLOCNO_HARD_REGNO (a) = -1;
    4438                 :            :   else
    4439                 :            :     {
    4440                 :          0 :       ira_assert (ira_class_hard_reg_index[aclass][hard_regno] >= 0);
    4441                 :          0 :       ira_overall_cost
    4442                 :          0 :         -= (ALLOCNO_MEMORY_COST (a)
    4443                 :          0 :             - (ALLOCNO_HARD_REG_COSTS (a) == NULL
    4444                 :          0 :                ? ALLOCNO_CLASS_COST (a)
    4445                 :            :                : ALLOCNO_HARD_REG_COSTS (a)[ira_class_hard_reg_index
    4446                 :          0 :                                             [aclass][hard_regno]]));
    4447                 :          0 :       if (ira_need_caller_save_p (a, hard_regno))
    4448                 :            :         {
    4449                 :          0 :           ira_assert (flag_caller_saves);
    4450                 :          0 :           caller_save_needed = 1;
    4451                 :            :         }
    4452                 :            :     }
    4453                 :            : 
    4454                 :            :   /* If we found a hard register, modify the RTL for the pseudo
    4455                 :            :      register to show the hard register, and mark the pseudo register
    4456                 :            :      live.  */
    4457                 :          0 :   if (reg_renumber[regno] >= 0)
    4458                 :            :     {
    4459                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4460                 :          0 :         fprintf (ira_dump_file, ": reassign to %d\n", reg_renumber[regno]);
    4461                 :          0 :       SET_REGNO (regno_reg_rtx[regno], reg_renumber[regno]);
    4462                 :          0 :       mark_home_live (regno);
    4463                 :            :     }
    4464                 :          0 :   else if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4465                 :          0 :     fprintf (ira_dump_file, "\n");
    4466                 :          0 :   for (i = 0; i < n; i++)
    4467                 :            :     {
    4468                 :          0 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    4469                 :          0 :       OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) = saved[i];
    4470                 :            :     }
    4471                 :          0 :   return reg_renumber[regno] >= 0;
    4472                 :            : }
    4473                 :            : 
    4474                 :            : /* Sort pseudos according their usage frequencies (putting most
    4475                 :            :    frequently ones first).  */
    4476                 :            : static int
    4477                 :          0 : pseudo_reg_compare (const void *v1p, const void *v2p)
    4478                 :            : {
    4479                 :          0 :   int regno1 = *(const int *) v1p;
    4480                 :          0 :   int regno2 = *(const int *) v2p;
    4481                 :          0 :   int diff;
    4482                 :            : 
    4483                 :          0 :   if ((diff = REG_FREQ (regno2) - REG_FREQ (regno1)) != 0)
    4484                 :            :     return diff;
    4485                 :          0 :   return regno1 - regno2;
    4486                 :            : }
    4487                 :            : 
    4488                 :            : /* Try to allocate hard registers to SPILLED_PSEUDO_REGS (there are
    4489                 :            :    NUM of them) or spilled pseudos conflicting with pseudos in
    4490                 :            :    SPILLED_PSEUDO_REGS.  Return TRUE and update SPILLED, if the
    4491                 :            :    allocation has been changed.  The function doesn't use
    4492                 :            :    BAD_SPILL_REGS and hard registers in PSEUDO_FORBIDDEN_REGS and
    4493                 :            :    PSEUDO_PREVIOUS_REGS for the corresponding pseudos.  The function
    4494                 :            :    is called by the reload pass at the end of each reload
    4495                 :            :    iteration.  */
    4496                 :            : bool
    4497                 :          0 : ira_reassign_pseudos (int *spilled_pseudo_regs, int num,
    4498                 :            :                       HARD_REG_SET bad_spill_regs,
    4499                 :            :                       HARD_REG_SET *pseudo_forbidden_regs,
    4500                 :            :                       HARD_REG_SET *pseudo_previous_regs,
    4501                 :            :                       bitmap spilled)
    4502                 :            : {
    4503                 :          0 :   int i, n, regno;
    4504                 :          0 :   bool changed_p;
    4505                 :          0 :   ira_allocno_t a;
    4506                 :          0 :   HARD_REG_SET forbidden_regs;
    4507                 :          0 :   bitmap temp = BITMAP_ALLOC (NULL);
    4508                 :            : 
    4509                 :            :   /* Add pseudos which conflict with pseudos already in
    4510                 :            :      SPILLED_PSEUDO_REGS to SPILLED_PSEUDO_REGS.  This is preferable
    4511                 :            :      to allocating in two steps as some of the conflicts might have
    4512                 :            :      a higher priority than the pseudos passed in SPILLED_PSEUDO_REGS.  */
    4513                 :          0 :   for (i = 0; i < num; i++)
    4514                 :          0 :     bitmap_set_bit (temp, spilled_pseudo_regs[i]);
    4515                 :            : 
    4516                 :          0 :   for (i = 0, n = num; i < n; i++)
    4517                 :            :     {
    4518                 :          0 :       int nr, j;
    4519                 :          0 :       int regno = spilled_pseudo_regs[i];
    4520                 :          0 :       bitmap_set_bit (temp, regno);
    4521                 :            : 
    4522                 :          0 :       a = ira_regno_allocno_map[regno];
    4523                 :          0 :       nr = ALLOCNO_NUM_OBJECTS (a);
    4524                 :          0 :       for (j = 0; j < nr; j++)
    4525                 :            :         {
    4526                 :          0 :           ira_object_t conflict_obj;
    4527                 :          0 :           ira_object_t obj = ALLOCNO_OBJECT (a, j);
    4528                 :          0 :           ira_object_conflict_iterator oci;
    4529                 :            : 
    4530                 :          0 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    4531                 :            :             {
    4532                 :          0 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    4533                 :          0 :               if (ALLOCNO_HARD_REGNO (conflict_a) < 0
    4534                 :          0 :                   && ! ALLOCNO_DONT_REASSIGN_P (conflict_a)
    4535                 :          0 :                   && bitmap_set_bit (temp, ALLOCNO_REGNO (conflict_a)))
    4536                 :            :                 {
    4537                 :          0 :                   spilled_pseudo_regs[num++] = ALLOCNO_REGNO (conflict_a);
    4538                 :            :                   /* ?!? This seems wrong.  */
    4539                 :          0 :                   bitmap_set_bit (consideration_allocno_bitmap,
    4540                 :            :                                   ALLOCNO_NUM (conflict_a));
    4541                 :            :                 }
    4542                 :            :             }
    4543                 :            :         }
    4544                 :            :     }
    4545                 :            : 
    4546                 :          0 :   if (num > 1)
    4547                 :          0 :     qsort (spilled_pseudo_regs, num, sizeof (int), pseudo_reg_compare);
    4548                 :            :   changed_p = false;
    4549                 :            :   /* Try to assign hard registers to pseudos from
    4550                 :            :      SPILLED_PSEUDO_REGS.  */
    4551                 :          0 :   for (i = 0; i < num; i++)
    4552                 :            :     {
    4553                 :          0 :       regno = spilled_pseudo_regs[i];
    4554                 :          0 :       forbidden_regs = (bad_spill_regs
    4555                 :          0 :                         | pseudo_forbidden_regs[regno]
    4556                 :          0 :                         | pseudo_previous_regs[regno]);
    4557                 :          0 :       gcc_assert (reg_renumber[regno] < 0);
    4558                 :          0 :       a = ira_regno_allocno_map[regno];
    4559                 :          0 :       ira_mark_allocation_change (regno);
    4560                 :          0 :       ira_assert (reg_renumber[regno] < 0);
    4561                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    4562                 :          0 :         fprintf (ira_dump_file,
    4563                 :            :                  "      Try Assign %d(a%d), cost=%d", regno, ALLOCNO_NUM (a),
    4564                 :          0 :                  ALLOCNO_MEMORY_COST (a)
    4565                 :          0 :                  - ALLOCNO_CLASS_COST (a));
    4566                 :          0 :       allocno_reload_assign (a, forbidden_regs);
    4567                 :          0 :       if (reg_renumber[regno] >= 0)
    4568                 :            :         {
    4569                 :          0 :           CLEAR_REGNO_REG_SET (spilled, regno);
    4570                 :          0 :           changed_p = true;
    4571                 :            :         }
    4572                 :            :     }
    4573                 :          0 :   BITMAP_FREE (temp);
    4574                 :          0 :   return changed_p;
    4575                 :            : }
    4576                 :            : 
    4577                 :            : /* The function is called by reload and returns already allocated
    4578                 :            :    stack slot (if any) for REGNO with given INHERENT_SIZE and
    4579                 :            :    TOTAL_SIZE.  In the case of failure to find a slot which can be
    4580                 :            :    used for REGNO, the function returns NULL.  */
    4581                 :            : rtx
    4582                 :          0 : ira_reuse_stack_slot (int regno, poly_uint64 inherent_size,
    4583                 :            :                       poly_uint64 total_size)
    4584                 :            : {
    4585                 :          0 :   unsigned int i;
    4586                 :          0 :   int slot_num, best_slot_num;
    4587                 :          0 :   int cost, best_cost;
    4588                 :          0 :   ira_copy_t cp, next_cp;
    4589                 :          0 :   ira_allocno_t another_allocno, allocno = ira_regno_allocno_map[regno];
    4590                 :          0 :   rtx x;
    4591                 :          0 :   bitmap_iterator bi;
    4592                 :          0 :   class ira_spilled_reg_stack_slot *slot = NULL;
    4593                 :            : 
    4594                 :          0 :   ira_assert (! ira_use_lra_p);
    4595                 :            : 
    4596                 :          0 :   ira_assert (known_eq (inherent_size, PSEUDO_REGNO_BYTES (regno))
    4597                 :            :               && known_le (inherent_size, total_size)
    4598                 :            :               && ALLOCNO_HARD_REGNO (allocno) < 0);
    4599                 :          0 :   if (! flag_ira_share_spill_slots)
    4600                 :            :     return NULL_RTX;
    4601                 :          0 :   slot_num = -ALLOCNO_HARD_REGNO (allocno) - 2;
    4602                 :          0 :   if (slot_num != -1)
    4603                 :            :     {
    4604                 :          0 :       slot = &ira_spilled_reg_stack_slots[slot_num];
    4605                 :          0 :       x = slot->mem;
    4606                 :            :     }
    4607                 :            :   else
    4608                 :            :     {
    4609                 :            :       best_cost = best_slot_num = -1;
    4610                 :          0 :       x = NULL_RTX;
    4611                 :            :       /* It means that the pseudo was spilled in the reload pass, try
    4612                 :            :          to reuse a slot.  */
    4613                 :          0 :       for (slot_num = 0;
    4614                 :          0 :            slot_num < ira_spilled_reg_stack_slots_num;
    4615                 :            :            slot_num++)
    4616                 :            :         {
    4617                 :          0 :           slot = &ira_spilled_reg_stack_slots[slot_num];
    4618                 :          0 :           if (slot->mem == NULL_RTX)
    4619                 :          0 :             continue;
    4620                 :          0 :           if (maybe_lt (slot->width, total_size)
    4621                 :          0 :               || maybe_lt (GET_MODE_SIZE (GET_MODE (slot->mem)), inherent_size))
    4622                 :          0 :             continue;
    4623                 :            : 
    4624                 :          0 :           EXECUTE_IF_SET_IN_BITMAP (&slot->spilled_regs,
    4625                 :            :                                     FIRST_PSEUDO_REGISTER, i, bi)
    4626                 :            :             {
    4627                 :          0 :               another_allocno = ira_regno_allocno_map[i];
    4628                 :          0 :               if (allocnos_conflict_by_live_ranges_p (allocno,
    4629                 :            :                                                       another_allocno))
    4630                 :          0 :                 goto cont;
    4631                 :            :             }
    4632                 :          0 :           for (cost = 0, cp = ALLOCNO_COPIES (allocno);
    4633                 :          0 :                cp != NULL;
    4634                 :            :                cp = next_cp)
    4635                 :            :             {
    4636                 :          0 :               if (cp->first == allocno)
    4637                 :            :                 {
    4638                 :          0 :                   next_cp = cp->next_first_allocno_copy;
    4639                 :          0 :                   another_allocno = cp->second;
    4640                 :            :                 }
    4641                 :          0 :               else if (cp->second == allocno)
    4642                 :            :                 {
    4643                 :          0 :                   next_cp = cp->next_second_allocno_copy;
    4644                 :          0 :                   another_allocno = cp->first;
    4645                 :            :                 }
    4646                 :            :               else
    4647                 :          0 :                 gcc_unreachable ();
    4648                 :          0 :               if (cp->insn == NULL_RTX)
    4649                 :          0 :                 continue;
    4650                 :          0 :               if (bitmap_bit_p (&slot->spilled_regs,
    4651                 :            :                                 ALLOCNO_REGNO (another_allocno)))
    4652                 :          0 :                 cost += cp->freq;
    4653                 :            :             }
    4654                 :          0 :           if (cost > best_cost)
    4655                 :            :             {
    4656                 :          0 :               best_cost = cost;
    4657                 :          0 :               best_slot_num = slot_num;
    4658                 :            :             }
    4659                 :          0 :         cont:
    4660                 :          0 :           ;
    4661                 :            :         }
    4662                 :          0 :       if (best_cost >= 0)
    4663                 :            :         {
    4664                 :          0 :           slot_num = best_slot_num;
    4665                 :          0 :           slot = &ira_spilled_reg_stack_slots[slot_num];
    4666                 :          0 :           SET_REGNO_REG_SET (&slot->spilled_regs, regno);
    4667                 :          0 :           x = slot->mem;
    4668                 :          0 :           ALLOCNO_HARD_REGNO (allocno) = -slot_num - 2;
    4669                 :            :         }
    4670                 :            :     }
    4671                 :          0 :   if (x != NULL_RTX)
    4672                 :            :     {
    4673                 :          0 :       ira_assert (known_ge (slot->width, total_size));
    4674                 :            : #ifdef ENABLE_IRA_CHECKING
    4675                 :          0 :       EXECUTE_IF_SET_IN_BITMAP (&slot->spilled_regs,
    4676                 :            :                                 FIRST_PSEUDO_REGISTER, i, bi)
    4677                 :            :         {
    4678                 :          0 :           ira_assert (! conflict_by_live_ranges_p (regno, i));
    4679                 :            :         }
    4680                 :            : #endif
    4681                 :          0 :       SET_REGNO_REG_SET (&slot->spilled_regs, regno);
    4682                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file)
    4683                 :            :         {
    4684                 :          0 :           fprintf (ira_dump_file, "      Assigning %d(freq=%d) slot %d of",
    4685                 :          0 :                    regno, REG_FREQ (regno), slot_num);
    4686                 :          0 :           EXECUTE_IF_SET_IN_BITMAP (&slot->spilled_regs,
    4687                 :            :                                     FIRST_PSEUDO_REGISTER, i, bi)
    4688                 :            :             {
    4689                 :          0 :               if ((unsigned) regno != i)
    4690                 :          0 :                 fprintf (ira_dump_file, " %d", i);
    4691                 :            :             }
    4692                 :          0 :           fprintf (ira_dump_file, "\n");
    4693                 :            :         }
    4694                 :            :     }
    4695                 :            :   return x;
    4696                 :            : }
    4697                 :            : 
    4698                 :            : /* This is called by reload every time a new stack slot X with
    4699                 :            :    TOTAL_SIZE was allocated for REGNO.  We store this info for
    4700                 :            :    subsequent ira_reuse_stack_slot calls.  */
    4701                 :            : void
    4702                 :          0 : ira_mark_new_stack_slot (rtx x, int regno, poly_uint64 total_size)
    4703                 :            : {
    4704                 :          0 :   class ira_spilled_reg_stack_slot *slot;
    4705                 :          0 :   int slot_num;
    4706                 :          0 :   ira_allocno_t allocno;
    4707                 :            : 
    4708                 :          0 :   ira_assert (! ira_use_lra_p);
    4709                 :            : 
    4710                 :          0 :   ira_assert (known_le (PSEUDO_REGNO_BYTES (regno), total_size));
    4711                 :          0 :   allocno = ira_regno_allocno_map[regno];
    4712                 :          0 :   slot_num = -ALLOCNO_HARD_REGNO (allocno) - 2;
    4713                 :          0 :   if (slot_num == -1)
    4714                 :            :     {
    4715                 :          0 :       slot_num = ira_spilled_reg_stack_slots_num++;
    4716                 :          0 :       ALLOCNO_HARD_REGNO (allocno) = -slot_num - 2;
    4717                 :            :     }
    4718                 :          0 :   slot = &ira_spilled_reg_stack_slots[slot_num];
    4719                 :          0 :   INIT_REG_SET (&slot->spilled_regs);
    4720                 :          0 :   SET_REGNO_REG_SET (&slot->spilled_regs, regno);
    4721                 :          0 :   slot->mem = x;
    4722                 :          0 :   slot->width = total_size;
    4723                 :          0 :   if (internal_flag_ira_verbose > 3 && ira_dump_file)
    4724                 :          0 :     fprintf (ira_dump_file, "      Assigning %d(freq=%d) a new slot %d\n",
    4725                 :          0 :              regno, REG_FREQ (regno), slot_num);
    4726                 :          0 : }
    4727                 :            : 
    4728                 :            : 
    4729                 :            : /* Return spill cost for pseudo-registers whose numbers are in array
    4730                 :            :    REGNOS (with a negative number as an end marker) for reload with
    4731                 :            :    given IN and OUT for INSN.  Return also number points (through
    4732                 :            :    EXCESS_PRESSURE_LIVE_LENGTH) where the pseudo-register lives and
    4733                 :            :    the register pressure is high, number of references of the
    4734                 :            :    pseudo-registers (through NREFS), the number of psuedo registers
    4735                 :            :    whose allocated register wouldn't need saving in the prologue
    4736                 :            :    (through CALL_USED_COUNT), and the first hard regno occupied by the
    4737                 :            :    pseudo-registers (through FIRST_HARD_REGNO).  */
    4738                 :            : static int
    4739                 :          0 : calculate_spill_cost (int *regnos, rtx in, rtx out, rtx_insn *insn,
    4740                 :            :                       int *excess_pressure_live_length,
    4741                 :            :                       int *nrefs, int *call_used_count, int *first_hard_regno)
    4742                 :            : {
    4743                 :          0 :   int i, cost, regno, hard_regno, count, saved_cost;
    4744                 :          0 :   bool in_p, out_p;
    4745                 :          0 :   int length;
    4746                 :          0 :   ira_allocno_t a;
    4747                 :            : 
    4748                 :          0 :   *nrefs = 0;
    4749                 :          0 :   for (length = count = cost = i = 0;; i++)
    4750                 :            :     {
    4751                 :          0 :       regno = regnos[i];
    4752                 :          0 :       if (regno < 0)
    4753                 :            :         break;
    4754                 :          0 :       *nrefs += REG_N_REFS (regno);
    4755                 :          0 :       hard_regno = reg_renumber[regno];
    4756                 :          0 :       ira_assert (hard_regno >= 0);
    4757                 :          0 :       a = ira_regno_allocno_map[regno];
    4758                 :          0 :       length += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a) / ALLOCNO_NUM_OBJECTS (a);
    4759                 :          0 :       cost += ALLOCNO_MEMORY_COST (a) - ALLOCNO_CLASS_COST (a);
    4760                 :          0 :       if (in_hard_reg_set_p (crtl->abi->full_reg_clobbers (),
    4761                 :          0 :                              ALLOCNO_MODE (a), hard_regno))
    4762                 :          0 :         count++;
    4763                 :          0 :       in_p = in && REG_P (in) && (int) REGNO (in) == hard_regno;
    4764                 :          0 :       out_p = out && REG_P (out) && (int) REGNO (out) == hard_regno;
    4765                 :          0 :       if ((in_p || out_p)
    4766                 :          0 :           && find_regno_note (insn, REG_DEAD, hard_regno) != NULL_RTX)
    4767                 :            :         {
    4768                 :          0 :           saved_cost = 0;
    4769                 :          0 :           if (in_p)
    4770                 :          0 :             saved_cost += ira_memory_move_cost
    4771                 :          0 :                           [ALLOCNO_MODE (a)][ALLOCNO_CLASS (a)][1];
    4772                 :          0 :           if (out_p)
    4773                 :          0 :             saved_cost
    4774                 :          0 :               += ira_memory_move_cost
    4775                 :          0 :                  [ALLOCNO_MODE (a)][ALLOCNO_CLASS (a)][0];
    4776                 :          0 :           cost -= REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn)) * saved_cost;
    4777                 :            :         }
    4778                 :            :     }
    4779                 :          0 :   *excess_pressure_live_length = length;
    4780                 :          0 :   *call_used_count = count;
    4781                 :          0 :   hard_regno = -1;
    4782                 :          0 :   if (regnos[0] >= 0)
    4783                 :            :     {
    4784                 :          0 :       hard_regno = reg_renumber[regnos[0]];
    4785                 :            :     }
    4786                 :          0 :   *first_hard_regno = hard_regno;
    4787                 :          0 :   return cost;
    4788                 :            : }
    4789                 :            : 
    4790                 :            : /* Return TRUE if spilling pseudo-registers whose numbers are in array
    4791                 :            :    REGNOS is better than spilling pseudo-registers with numbers in
    4792                 :            :    OTHER_REGNOS for reload with given IN and OUT for INSN.  The
    4793                 :            :    function used by the reload pass to make better register spilling
    4794                 :            :    decisions.  */
    4795                 :            : bool
    4796                 :          0 : ira_better_spill_reload_regno_p (int *regnos, int *other_regnos,
    4797                 :            :                                  rtx in, rtx out, rtx_insn *insn)
    4798                 :            : {
    4799                 :          0 :   int cost, other_cost;
    4800                 :          0 :   int length, other_length;
    4801                 :          0 :   int nrefs, other_nrefs;
    4802                 :          0 :   int call_used_count, other_call_used_count;
    4803                 :          0 :   int hard_regno, other_hard_regno;
    4804                 :            : 
    4805                 :          0 :   cost = calculate_spill_cost (regnos, in, out, insn,
    4806                 :            :                                &length, &nrefs, &call_used_count, &hard_regno);
    4807                 :          0 :   other_cost = calculate_spill_cost (other_regnos, in, out, insn,
    4808                 :            :                                      &other_length, &other_nrefs,
    4809                 :            :                                      &other_call_used_count,
    4810                 :            :                                      &other_hard_regno);
    4811                 :          0 :   if (nrefs == 0 && other_nrefs != 0)
    4812                 :            :     return true;
    4813                 :          0 :   if (nrefs != 0 && other_nrefs == 0)
    4814                 :            :     return false;
    4815                 :          0 :   if (cost != other_cost)
    4816                 :          0 :     return cost < other_cost;
    4817                 :          0 :   if (length != other_length)
    4818                 :          0 :     return length > other_length;
    4819                 :            : #ifdef REG_ALLOC_ORDER
    4820                 :          0 :   if (hard_regno >= 0 && other_hard_regno >= 0)
    4821                 :          0 :     return (inv_reg_alloc_order[hard_regno]
    4822                 :          0 :             < inv_reg_alloc_order[other_hard_regno]);
    4823                 :            : #else
    4824                 :            :   if (call_used_count != other_call_used_count)
    4825                 :            :     return call_used_count > other_call_used_count;
    4826                 :            : #endif
    4827                 :            :   return false;
    4828                 :            : }
    4829                 :            : 
    4830                 :            : 
    4831                 :            : 
    4832                 :            : /* Allocate and initialize data necessary for assign_hard_reg.  */
    4833                 :            : void
    4834                 :     688548 : ira_initiate_assign (void)
    4835                 :            : {
    4836                 :     688548 :   sorted_allocnos
    4837                 :    1377100 :     = (ira_allocno_t *) ira_allocate (sizeof (ira_allocno_t)
    4838                 :     688548 :                                       * ira_allocnos_num);
    4839                 :     688548 :   consideration_allocno_bitmap = ira_allocate_bitmap ();
    4840                 :     688548 :   initiate_cost_update ();
    4841                 :     688548 :   allocno_priorities = (int *) ira_allocate (sizeof (int) * ira_allocnos_num);
    4842                 :     688548 :   sorted_copies = (ira_copy_t *) ira_allocate (ira_copies_num
    4843                 :            :                                                * sizeof (ira_copy_t));
    4844                 :     688548 : }
    4845                 :            : 
    4846                 :            : /* Deallocate data used by assign_hard_reg.  */
    4847                 :            : void
    4848                 :     688548 : ira_finish_assign (void)
    4849                 :            : {
    4850                 :     688548 :   ira_free (sorted_allocnos);
    4851                 :     688548 :   ira_free_bitmap (consideration_allocno_bitmap);
    4852                 :     688548 :   finish_cost_update ();
    4853                 :     688548 :   ira_free (allocno_priorities);
    4854                 :     688548 :   ira_free (sorted_copies);
    4855                 :     688548 : }
    4856                 :            : 
    4857                 :            : 
    4858                 :            : 
    4859                 :            : /* Entry function doing color-based register allocation.  */
    4860                 :            : static void
    4861                 :     688548 : color (void)
    4862                 :            : {
    4863                 :     688548 :   allocno_stack_vec.create (ira_allocnos_num);
    4864                 :     688548 :   memset (allocated_hardreg_p, 0, sizeof (allocated_hardreg_p));
    4865                 :     688548 :   ira_initiate_assign ();
    4866                 :     688548 :   do_coloring ();
    4867                 :     688548 :   ira_finish_assign ();
    4868                 :     688548 :   allocno_stack_vec.release ();
    4869                 :     688548 :   move_spill_restore ();
    4870                 :     688548 : }
    4871                 :            : 
    4872                 :            : 
    4873                 :            : 
    4874                 :            : /* This page contains a simple register allocator without usage of
    4875                 :            :    allocno conflicts.  This is used for fast allocation for -O0.  */
    4876                 :            : 
    4877                 :            : /* Do register allocation by not using allocno conflicts.  It uses
    4878                 :            :    only allocno live ranges.  The algorithm is close to Chow's
    4879                 :            :    priority coloring.  */
    4880                 :            : static void
    4881                 :     255548 : fast_allocation (void)
    4882                 :            : {
    4883                 :     255548 :   int i, j, k, num, class_size, hard_regno, best_hard_regno, cost, min_cost;
    4884                 :     255548 :   int *costs;
    4885                 :            : #ifdef STACK_REGS
    4886                 :     255548 :   bool no_stack_reg_p;
    4887                 :            : #endif
    4888                 :     255548 :   enum reg_class aclass;
    4889                 :     255548 :   machine_mode mode;
    4890                 :     255548 :   ira_allocno_t a;
    4891                 :     255548 :   ira_allocno_iterator ai;
    4892                 :     255548 :   live_range_t r;
    4893                 :     255548 :   HARD_REG_SET conflict_hard_regs, *used_hard_regs;
    4894                 :            : 
    4895                 :     511096 :   sorted_allocnos = (ira_allocno_t *) ira_allocate (sizeof (ira_allocno_t)
    4896                 :     255548 :                                                     * ira_allocnos_num);
    4897                 :     255548 :   num = 0;
    4898                 :    6210730 :   FOR_EACH_ALLOCNO (a, ai)
    4899                 :    5955180 :     sorted_allocnos[num++] = a;
    4900                 :     255548 :   allocno_priorities = (int *) ira_allocate (sizeof (int) * ira_allocnos_num);
    4901                 :     255548 :   setup_allocno_priorities (sorted_allocnos, num);
    4902                 :     255548 :   used_hard_regs = (HARD_REG_SET *) ira_allocate (sizeof (HARD_REG_SET)
    4903                 :     255548 :                                                   * ira_max_point);
    4904                 :   10068700 :   for (i = 0; i < ira_max_point; i++)
    4905                 :   19626300 :     CLEAR_HARD_REG_SET (used_hard_regs[i]);
    4906                 :     255548 :   qsort (sorted_allocnos, num, sizeof (ira_allocno_t),
    4907                 :            :          allocno_priority_compare_func);
    4908                 :    6210730 :   for (i = 0; i < num; i++)
    4909                 :            :     {
    4910                 :    5955180 :       int nr, l;
    4911                 :            : 
    4912                 :    5955180 :       a = sorted_allocnos[i];
    4913                 :    5955180 :       nr = ALLOCNO_NUM_OBJECTS (a);
    4914                 :    5955180 :       CLEAR_HARD_REG_SET (conflict_hard_regs);
    4915                 :   12173700 :       for (l = 0; l < nr; l++)
    4916                 :            :         {
    4917                 :    6218480 :           ira_object_t obj = ALLOCNO_OBJECT (a, l);
    4918                 :    6218480 :           conflict_hard_regs |= OBJECT_CONFLICT_HARD_REGS (obj);
    4919                 :   15058500 :           for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
    4920                 :  872987000 :             for (j = r->start; j <= r->finish; j++)
    4921                 : 1728290000 :               conflict_hard_regs |= used_hard_regs[j];
    4922                 :            :         }
    4923                 :    5955180 :       aclass = ALLOCNO_CLASS (a);
    4924                 :    5955180 :       ALLOCNO_ASSIGNED_P (a) = true;
    4925                 :    5955180 :       ALLOCNO_HARD_REGNO (a) = -1;
    4926                 :   11910400 :       if (hard_reg_set_subset_p (reg_class_contents[aclass],
    4927                 :            :                                  conflict_hard_regs))
    4928                 :      67699 :         continue;
    4929                 :    5887480 :       mode = ALLOCNO_MODE (a);
    4930                 :            : #ifdef STACK_REGS
    4931                 :    5887480 :       no_stack_reg_p = ALLOCNO_NO_STACK_REG_P (a);
    4932                 :            : #endif
    4933                 :    5887480 :       class_size = ira_class_hard_regs_num[aclass];
    4934                 :    5887480 :       costs = ALLOCNO_HARD_REG_COSTS (a);
    4935                 :    5887480 :       min_cost = INT_MAX;
    4936                 :    5887480 :       best_hard_regno = -1;
    4937                 :   14844900 :       for (j = 0; j < class_size; j++)
    4938                 :            :         {
    4939                 :   14527200 :           hard_regno = ira_class_hard_regs[aclass][j];
    4940                 :            : #ifdef STACK_REGS
    4941                 :   14527200 :           if (no_stack_reg_p && FIRST_STACK_REG <= hard_regno
    4942                 :       9642 :               && hard_regno <= LAST_STACK_REG)
    4943                 :          0 :             continue;
    4944                 :            : #endif
    4945                 :   14527200 :           if (ira_hard_reg_set_intersection_p (hard_regno, mode, conflict_hard_regs)
    4946                 :   14527200 :               || (TEST_HARD_REG_BIT
    4947                 :   10893900 :                   (ira_prohibited_class_mode_regs[aclass][mode], hard_regno)))
    4948                 :    3778970 :             continue;
    4949                 :   10748200 :           if (costs == NULL)
    4950                 :            :             {
    4951                 :            :               best_hard_regno = hard_regno;
    4952                 :            :               break;
    4953                 :            :             }
    4954                 :    5178410 :           cost = costs[j];
    4955                 :    5178410 :           if (min_cost > cost)
    4956                 :            :             {
    4957                 :     384462 :               min_cost = cost;
    4958                 :     384462 :               best_hard_regno = hard_regno;
    4959                 :            :             }
    4960                 :            :         }
    4961                 :    5887480 :       if (best_hard_regno < 0)
    4962                 :       2136 :         continue;
    4963                 :    5885350 :       ALLOCNO_HARD_REGNO (a) = hard_regno = best_hard_regno;
    4964                 :   12007700 :       for (l = 0; l < nr; l++)
    4965                 :            :         {
    4966                 :    6122340 :           ira_object_t obj = ALLOCNO_OBJECT (a, l);
    4967                 :   12361500 :           for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
    4968                 :   25366700 :             for (k = r->start; k <= r->finish; k++)
    4969                 :   38255200 :               used_hard_regs[k] |= ira_reg_mode_hard_regset[hard_regno][mode];
    4970                 :            :         }
    4971                 :            :     }
    4972                 :     255548 :   ira_free (sorted_allocnos);
    4973                 :     255548 :   ira_free (used_hard_regs);
    4974                 :     255548 :   ira_free (allocno_priorities);
    4975                 :     255548 :   if (internal_flag_ira_verbose > 1 && ira_dump_file != NULL)
    4976                 :         63 :     ira_print_disposition (ira_dump_file);
    4977                 :     255548 : }
    4978                 :            : 
    4979                 :            : 
    4980                 :            : 
    4981                 :            : /* Entry function doing coloring.  */
    4982                 :            : void
    4983                 :     944096 : ira_color (void)
    4984                 :            : {
    4985                 :     944096 :   ira_allocno_t a;
    4986                 :     944096 :   ira_allocno_iterator ai;
    4987                 :            : 
    4988                 :            :   /* Setup updated costs.  */
    4989                 :   23853700 :   FOR_EACH_ALLOCNO (a, ai)
    4990                 :            :     {
    4991                 :   22909600 :       ALLOCNO_UPDATED_MEMORY_COST (a) = ALLOCNO_MEMORY_COST (a);
    4992                 :   22909600 :       ALLOCNO_UPDATED_CLASS_COST (a) = ALLOCNO_CLASS_COST (a);
    4993                 :            :     }
    4994                 :     944096 :   if (ira_conflicts_p)
    4995                 :     688548 :     color ();
    4996                 :            :   else
    4997                 :     255548 :     fast_allocation ();
    4998                 :     944096 : }

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.