LCOV - code coverage report
Current view: top level - gcc - ira.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 83.8 % 2762 2314
Test Date: 2024-09-28 13:20:55 Functions: 82.9 % 105 87
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Integrated Register Allocator (IRA) entry point.
       2                 :             :    Copyright (C) 2006-2024 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                 :             : /* The integrated register allocator (IRA) is a
      22                 :             :    regional register allocator performing graph coloring on a top-down
      23                 :             :    traversal of nested regions.  Graph coloring in a region is based
      24                 :             :    on Chaitin-Briggs algorithm.  It is called integrated because
      25                 :             :    register coalescing, register live range splitting, and choosing a
      26                 :             :    better hard register are done on-the-fly during coloring.  Register
      27                 :             :    coalescing and choosing a cheaper hard register is done by hard
      28                 :             :    register preferencing during hard register assigning.  The live
      29                 :             :    range splitting is a byproduct of the regional register allocation.
      30                 :             : 
      31                 :             :    Major IRA notions are:
      32                 :             : 
      33                 :             :      o *Region* is a part of CFG where graph coloring based on
      34                 :             :        Chaitin-Briggs algorithm is done.  IRA can work on any set of
      35                 :             :        nested CFG regions forming a tree.  Currently the regions are
      36                 :             :        the entire function for the root region and natural loops for
      37                 :             :        the other regions.  Therefore data structure representing a
      38                 :             :        region is called loop_tree_node.
      39                 :             : 
      40                 :             :      o *Allocno class* is a register class used for allocation of
      41                 :             :        given allocno.  It means that only hard register of given
      42                 :             :        register class can be assigned to given allocno.  In reality,
      43                 :             :        even smaller subset of (*profitable*) hard registers can be
      44                 :             :        assigned.  In rare cases, the subset can be even smaller
      45                 :             :        because our modification of Chaitin-Briggs algorithm requires
      46                 :             :        that sets of hard registers can be assigned to allocnos forms a
      47                 :             :        forest, i.e. the sets can be ordered in a way where any
      48                 :             :        previous set is not intersected with given set or is a superset
      49                 :             :        of given set.
      50                 :             : 
      51                 :             :      o *Pressure class* is a register class belonging to a set of
      52                 :             :        register classes containing all of the hard-registers available
      53                 :             :        for register allocation.  The set of all pressure classes for a
      54                 :             :        target is defined in the corresponding machine-description file
      55                 :             :        according some criteria.  Register pressure is calculated only
      56                 :             :        for pressure classes and it affects some IRA decisions as
      57                 :             :        forming allocation regions.
      58                 :             : 
      59                 :             :      o *Allocno* represents the live range of a pseudo-register in a
      60                 :             :        region.  Besides the obvious attributes like the corresponding
      61                 :             :        pseudo-register number, allocno class, conflicting allocnos and
      62                 :             :        conflicting hard-registers, there are a few allocno attributes
      63                 :             :        which are important for understanding the allocation algorithm:
      64                 :             : 
      65                 :             :        - *Live ranges*.  This is a list of ranges of *program points*
      66                 :             :          where the allocno lives.  Program points represent places
      67                 :             :          where a pseudo can be born or become dead (there are
      68                 :             :          approximately two times more program points than the insns)
      69                 :             :          and they are represented by integers starting with 0.  The
      70                 :             :          live ranges are used to find conflicts between allocnos.
      71                 :             :          They also play very important role for the transformation of
      72                 :             :          the IRA internal representation of several regions into a one
      73                 :             :          region representation.  The later is used during the reload
      74                 :             :          pass work because each allocno represents all of the
      75                 :             :          corresponding pseudo-registers.
      76                 :             : 
      77                 :             :        - *Hard-register costs*.  This is a vector of size equal to the
      78                 :             :          number of available hard-registers of the allocno class.  The
      79                 :             :          cost of a callee-clobbered hard-register for an allocno is
      80                 :             :          increased by the cost of save/restore code around the calls
      81                 :             :          through the given allocno's life.  If the allocno is a move
      82                 :             :          instruction operand and another operand is a hard-register of
      83                 :             :          the allocno class, the cost of the hard-register is decreased
      84                 :             :          by the move cost.
      85                 :             : 
      86                 :             :          When an allocno is assigned, the hard-register with minimal
      87                 :             :          full cost is used.  Initially, a hard-register's full cost is
      88                 :             :          the corresponding value from the hard-register's cost vector.
      89                 :             :          If the allocno is connected by a *copy* (see below) to
      90                 :             :          another allocno which has just received a hard-register, the
      91                 :             :          cost of the hard-register is decreased.  Before choosing a
      92                 :             :          hard-register for an allocno, the allocno's current costs of
      93                 :             :          the hard-registers are modified by the conflict hard-register
      94                 :             :          costs of all of the conflicting allocnos which are not
      95                 :             :          assigned yet.
      96                 :             : 
      97                 :             :        - *Conflict hard-register costs*.  This is a vector of the same
      98                 :             :          size as the hard-register costs vector.  To permit an
      99                 :             :          unassigned allocno to get a better hard-register, IRA uses
     100                 :             :          this vector to calculate the final full cost of the
     101                 :             :          available hard-registers.  Conflict hard-register costs of an
     102                 :             :          unassigned allocno are also changed with a change of the
     103                 :             :          hard-register cost of the allocno when a copy involving the
     104                 :             :          allocno is processed as described above.  This is done to
     105                 :             :          show other unassigned allocnos that a given allocno prefers
     106                 :             :          some hard-registers in order to remove the move instruction
     107                 :             :          corresponding to the copy.
     108                 :             : 
     109                 :             :      o *Cap*.  If a pseudo-register does not live in a region but
     110                 :             :        lives in a nested region, IRA creates a special allocno called
     111                 :             :        a cap in the outer region.  A region cap is also created for a
     112                 :             :        subregion cap.
     113                 :             : 
     114                 :             :      o *Copy*.  Allocnos can be connected by copies.  Copies are used
     115                 :             :        to modify hard-register costs for allocnos during coloring.
     116                 :             :        Such modifications reflects a preference to use the same
     117                 :             :        hard-register for the allocnos connected by copies.  Usually
     118                 :             :        copies are created for move insns (in this case it results in
     119                 :             :        register coalescing).  But IRA also creates copies for operands
     120                 :             :        of an insn which should be assigned to the same hard-register
     121                 :             :        due to constraints in the machine description (it usually
     122                 :             :        results in removing a move generated in reload to satisfy
     123                 :             :        the constraints) and copies referring to the allocno which is
     124                 :             :        the output operand of an instruction and the allocno which is
     125                 :             :        an input operand dying in the instruction (creation of such
     126                 :             :        copies results in less register shuffling).  IRA *does not*
     127                 :             :        create copies between the same register allocnos from different
     128                 :             :        regions because we use another technique for propagating
     129                 :             :        hard-register preference on the borders of regions.
     130                 :             : 
     131                 :             :    Allocnos (including caps) for the upper region in the region tree
     132                 :             :    *accumulate* information important for coloring from allocnos with
     133                 :             :    the same pseudo-register from nested regions.  This includes
     134                 :             :    hard-register and memory costs, conflicts with hard-registers,
     135                 :             :    allocno conflicts, allocno copies and more.  *Thus, attributes for
     136                 :             :    allocnos in a region have the same values as if the region had no
     137                 :             :    subregions*.  It means that attributes for allocnos in the
     138                 :             :    outermost region corresponding to the function have the same values
     139                 :             :    as though the allocation used only one region which is the entire
     140                 :             :    function.  It also means that we can look at IRA work as if the
     141                 :             :    first IRA did allocation for all function then it improved the
     142                 :             :    allocation for loops then their subloops and so on.
     143                 :             : 
     144                 :             :    IRA major passes are:
     145                 :             : 
     146                 :             :      o Building IRA internal representation which consists of the
     147                 :             :        following subpasses:
     148                 :             : 
     149                 :             :        * First, IRA builds regions and creates allocnos (file
     150                 :             :          ira-build.cc) and initializes most of their attributes.
     151                 :             : 
     152                 :             :        * Then IRA finds an allocno class for each allocno and
     153                 :             :          calculates its initial (non-accumulated) cost of memory and
     154                 :             :          each hard-register of its allocno class (file ira-cost.c).
     155                 :             : 
     156                 :             :        * IRA creates live ranges of each allocno, calculates register
     157                 :             :          pressure for each pressure class in each region, sets up
     158                 :             :          conflict hard registers for each allocno and info about calls
     159                 :             :          the allocno lives through (file ira-lives.cc).
     160                 :             : 
     161                 :             :        * IRA removes low register pressure loops from the regions
     162                 :             :          mostly to speed IRA up (file ira-build.cc).
     163                 :             : 
     164                 :             :        * IRA propagates accumulated allocno info from lower region
     165                 :             :          allocnos to corresponding upper region allocnos (file
     166                 :             :          ira-build.cc).
     167                 :             : 
     168                 :             :        * IRA creates all caps (file ira-build.cc).
     169                 :             : 
     170                 :             :        * Having live-ranges of allocnos and their classes, IRA creates
     171                 :             :          conflicting allocnos for each allocno.  Conflicting allocnos
     172                 :             :          are stored as a bit vector or array of pointers to the
     173                 :             :          conflicting allocnos whatever is more profitable (file
     174                 :             :          ira-conflicts.cc).  At this point IRA creates allocno copies.
     175                 :             : 
     176                 :             :      o Coloring.  Now IRA has all necessary info to start graph coloring
     177                 :             :        process.  It is done in each region on top-down traverse of the
     178                 :             :        region tree (file ira-color.cc).  There are following subpasses:
     179                 :             : 
     180                 :             :        * Finding profitable hard registers of corresponding allocno
     181                 :             :          class for each allocno.  For example, only callee-saved hard
     182                 :             :          registers are frequently profitable for allocnos living
     183                 :             :          through colors.  If the profitable hard register set of
     184                 :             :          allocno does not form a tree based on subset relation, we use
     185                 :             :          some approximation to form the tree.  This approximation is
     186                 :             :          used to figure out trivial colorability of allocnos.  The
     187                 :             :          approximation is a pretty rare case.
     188                 :             : 
     189                 :             :        * Putting allocnos onto the coloring stack.  IRA uses Briggs
     190                 :             :          optimistic coloring which is a major improvement over
     191                 :             :          Chaitin's coloring.  Therefore IRA does not spill allocnos at
     192                 :             :          this point.  There is some freedom in the order of putting
     193                 :             :          allocnos on the stack which can affect the final result of
     194                 :             :          the allocation.  IRA uses some heuristics to improve the
     195                 :             :          order.  The major one is to form *threads* from colorable
     196                 :             :          allocnos and push them on the stack by threads.  Thread is a
     197                 :             :          set of non-conflicting colorable allocnos connected by
     198                 :             :          copies.  The thread contains allocnos from the colorable
     199                 :             :          bucket or colorable allocnos already pushed onto the coloring
     200                 :             :          stack.  Pushing thread allocnos one after another onto the
     201                 :             :          stack increases chances of removing copies when the allocnos
     202                 :             :          get the same hard reg.
     203                 :             :          
     204                 :             :          We also use a modification of Chaitin-Briggs algorithm which
     205                 :             :          works for intersected register classes of allocnos.  To
     206                 :             :          figure out trivial colorability of allocnos, the mentioned
     207                 :             :          above tree of hard register sets is used.  To get an idea how
     208                 :             :          the algorithm works in i386 example, let us consider an
     209                 :             :          allocno to which any general hard register can be assigned.
     210                 :             :          If the allocno conflicts with eight allocnos to which only
     211                 :             :          EAX register can be assigned, given allocno is still
     212                 :             :          trivially colorable because all conflicting allocnos might be
     213                 :             :          assigned only to EAX and all other general hard registers are
     214                 :             :          still free.
     215                 :             : 
     216                 :             :          To get an idea of the used trivial colorability criterion, it
     217                 :             :          is also useful to read article "Graph-Coloring Register
     218                 :             :          Allocation for Irregular Architectures" by Michael D. Smith
     219                 :             :          and Glen Holloway.  Major difference between the article
     220                 :             :          approach and approach used in IRA is that Smith's approach
     221                 :             :          takes register classes only from machine description and IRA
     222                 :             :          calculate register classes from intermediate code too
     223                 :             :          (e.g. an explicit usage of hard registers in RTL code for
     224                 :             :          parameter passing can result in creation of additional
     225                 :             :          register classes which contain or exclude the hard
     226                 :             :          registers).  That makes IRA approach useful for improving
     227                 :             :          coloring even for architectures with regular register files
     228                 :             :          and in fact some benchmarking shows the improvement for
     229                 :             :          regular class architectures is even bigger than for irregular
     230                 :             :          ones.  Another difference is that Smith's approach chooses
     231                 :             :          intersection of classes of all insn operands in which a given
     232                 :             :          pseudo occurs.  IRA can use bigger classes if it is still
     233                 :             :          more profitable than memory usage.
     234                 :             : 
     235                 :             :        * Popping the allocnos from the stack and assigning them hard
     236                 :             :          registers.  If IRA cannot assign a hard register to an
     237                 :             :          allocno and the allocno is coalesced, IRA undoes the
     238                 :             :          coalescing and puts the uncoalesced allocnos onto the stack in
     239                 :             :          the hope that some such allocnos will get a hard register
     240                 :             :          separately.  If IRA fails to assign hard register or memory
     241                 :             :          is more profitable for it, IRA spills the allocno.  IRA
     242                 :             :          assigns the allocno the hard-register with minimal full
     243                 :             :          allocation cost which reflects the cost of usage of the
     244                 :             :          hard-register for the allocno and cost of usage of the
     245                 :             :          hard-register for allocnos conflicting with given allocno.
     246                 :             : 
     247                 :             :        * Chaitin-Briggs coloring assigns as many pseudos as possible
     248                 :             :          to hard registers.  After coloring we try to improve
     249                 :             :          allocation with cost point of view.  We improve the
     250                 :             :          allocation by spilling some allocnos and assigning the freed
     251                 :             :          hard registers to other allocnos if it decreases the overall
     252                 :             :          allocation cost.
     253                 :             : 
     254                 :             :        * After allocno assigning in the region, IRA modifies the hard
     255                 :             :          register and memory costs for the corresponding allocnos in
     256                 :             :          the subregions to reflect the cost of possible loads, stores,
     257                 :             :          or moves on the border of the region and its subregions.
     258                 :             :          When default regional allocation algorithm is used
     259                 :             :          (-fira-algorithm=mixed), IRA just propagates the assignment
     260                 :             :          for allocnos if the register pressure in the region for the
     261                 :             :          corresponding pressure class is less than number of available
     262                 :             :          hard registers for given pressure class.
     263                 :             : 
     264                 :             :      o Spill/restore code moving.  When IRA performs an allocation
     265                 :             :        by traversing regions in top-down order, it does not know what
     266                 :             :        happens below in the region tree.  Therefore, sometimes IRA
     267                 :             :        misses opportunities to perform a better allocation.  A simple
     268                 :             :        optimization tries to improve allocation in a region having
     269                 :             :        subregions and containing in another region.  If the
     270                 :             :        corresponding allocnos in the subregion are spilled, it spills
     271                 :             :        the region allocno if it is profitable.  The optimization
     272                 :             :        implements a simple iterative algorithm performing profitable
     273                 :             :        transformations while they are still possible.  It is fast in
     274                 :             :        practice, so there is no real need for a better time complexity
     275                 :             :        algorithm.
     276                 :             : 
     277                 :             :      o Code change.  After coloring, two allocnos representing the
     278                 :             :        same pseudo-register outside and inside a region respectively
     279                 :             :        may be assigned to different locations (hard-registers or
     280                 :             :        memory).  In this case IRA creates and uses a new
     281                 :             :        pseudo-register inside the region and adds code to move allocno
     282                 :             :        values on the region's borders.  This is done during top-down
     283                 :             :        traversal of the regions (file ira-emit.cc).  In some
     284                 :             :        complicated cases IRA can create a new allocno to move allocno
     285                 :             :        values (e.g. when a swap of values stored in two hard-registers
     286                 :             :        is needed).  At this stage, the new allocno is marked as
     287                 :             :        spilled.  IRA still creates the pseudo-register and the moves
     288                 :             :        on the region borders even when both allocnos were assigned to
     289                 :             :        the same hard-register.  If the reload pass spills a
     290                 :             :        pseudo-register for some reason, the effect will be smaller
     291                 :             :        because another allocno will still be in the hard-register.  In
     292                 :             :        most cases, this is better then spilling both allocnos.  If
     293                 :             :        reload does not change the allocation for the two
     294                 :             :        pseudo-registers, the trivial move will be removed by
     295                 :             :        post-reload optimizations.  IRA does not generate moves for
     296                 :             :        allocnos assigned to the same hard register when the default
     297                 :             :        regional allocation algorithm is used and the register pressure
     298                 :             :        in the region for the corresponding pressure class is less than
     299                 :             :        number of available hard registers for given pressure class.
     300                 :             :        IRA also does some optimizations to remove redundant stores and
     301                 :             :        to reduce code duplication on the region borders.
     302                 :             : 
     303                 :             :      o Flattening internal representation.  After changing code, IRA
     304                 :             :        transforms its internal representation for several regions into
     305                 :             :        one region representation (file ira-build.cc).  This process is
     306                 :             :        called IR flattening.  Such process is more complicated than IR
     307                 :             :        rebuilding would be, but is much faster.
     308                 :             : 
     309                 :             :      o After IR flattening, IRA tries to assign hard registers to all
     310                 :             :        spilled allocnos.  This is implemented by a simple and fast
     311                 :             :        priority coloring algorithm (see function
     312                 :             :        ira_reassign_conflict_allocnos::ira-color.cc).  Here new allocnos
     313                 :             :        created during the code change pass can be assigned to hard
     314                 :             :        registers.
     315                 :             : 
     316                 :             :      o At the end IRA calls the reload pass.  The reload pass
     317                 :             :        communicates with IRA through several functions in file
     318                 :             :        ira-color.cc to improve its decisions in
     319                 :             : 
     320                 :             :        * sharing stack slots for the spilled pseudos based on IRA info
     321                 :             :          about pseudo-register conflicts.
     322                 :             : 
     323                 :             :        * reassigning hard-registers to all spilled pseudos at the end
     324                 :             :          of each reload iteration.
     325                 :             : 
     326                 :             :        * choosing a better hard-register to spill based on IRA info
     327                 :             :          about pseudo-register live ranges and the register pressure
     328                 :             :          in places where the pseudo-register lives.
     329                 :             : 
     330                 :             :    IRA uses a lot of data representing the target processors.  These
     331                 :             :    data are initialized in file ira.cc.
     332                 :             : 
     333                 :             :    If function has no loops (or the loops are ignored when
     334                 :             :    -fira-algorithm=CB is used), we have classic Chaitin-Briggs
     335                 :             :    coloring (only instead of separate pass of coalescing, we use hard
     336                 :             :    register preferencing).  In such case, IRA works much faster
     337                 :             :    because many things are not made (like IR flattening, the
     338                 :             :    spill/restore optimization, and the code change).
     339                 :             : 
     340                 :             :    Literature is worth to read for better understanding the code:
     341                 :             : 
     342                 :             :    o Preston Briggs, Keith D. Cooper, Linda Torczon.  Improvements to
     343                 :             :      Graph Coloring Register Allocation.
     344                 :             : 
     345                 :             :    o David Callahan, Brian Koblenz.  Register allocation via
     346                 :             :      hierarchical graph coloring.
     347                 :             : 
     348                 :             :    o Keith Cooper, Anshuman Dasgupta, Jason Eckhardt. Revisiting Graph
     349                 :             :      Coloring Register Allocation: A Study of the Chaitin-Briggs and
     350                 :             :      Callahan-Koblenz Algorithms.
     351                 :             : 
     352                 :             :    o Guei-Yuan Lueh, Thomas Gross, and Ali-Reza Adl-Tabatabai. Global
     353                 :             :      Register Allocation Based on Graph Fusion.
     354                 :             : 
     355                 :             :    o Michael D. Smith and Glenn Holloway.  Graph-Coloring Register
     356                 :             :      Allocation for Irregular Architectures
     357                 :             : 
     358                 :             :    o Vladimir Makarov. The Integrated Register Allocator for GCC.
     359                 :             : 
     360                 :             :    o Vladimir Makarov.  The top-down register allocator for irregular
     361                 :             :      register file architectures.
     362                 :             : 
     363                 :             : */
     364                 :             : 
     365                 :             : 
     366                 :             : #include "config.h"
     367                 :             : #include "system.h"
     368                 :             : #include "coretypes.h"
     369                 :             : #include "backend.h"
     370                 :             : #include "target.h"
     371                 :             : #include "rtl.h"
     372                 :             : #include "tree.h"
     373                 :             : #include "df.h"
     374                 :             : #include "memmodel.h"
     375                 :             : #include "tm_p.h"
     376                 :             : #include "insn-config.h"
     377                 :             : #include "regs.h"
     378                 :             : #include "ira.h"
     379                 :             : #include "ira-int.h"
     380                 :             : #include "diagnostic-core.h"
     381                 :             : #include "cfgrtl.h"
     382                 :             : #include "cfgbuild.h"
     383                 :             : #include "cfgcleanup.h"
     384                 :             : #include "expr.h"
     385                 :             : #include "tree-pass.h"
     386                 :             : #include "output.h"
     387                 :             : #include "reload.h"
     388                 :             : #include "cfgloop.h"
     389                 :             : #include "lra.h"
     390                 :             : #include "dce.h"
     391                 :             : #include "dbgcnt.h"
     392                 :             : #include "rtl-iter.h"
     393                 :             : #include "shrink-wrap.h"
     394                 :             : #include "print-rtl.h"
     395                 :             : 
     396                 :             : struct target_ira default_target_ira;
     397                 :             : class target_ira_int default_target_ira_int;
     398                 :             : #if SWITCHABLE_TARGET
     399                 :             : struct target_ira *this_target_ira = &default_target_ira;
     400                 :             : class target_ira_int *this_target_ira_int = &default_target_ira_int;
     401                 :             : #endif
     402                 :             : 
     403                 :             : /* A modified value of flag `-fira-verbose' used internally.  */
     404                 :             : int internal_flag_ira_verbose;
     405                 :             : 
     406                 :             : /* Dump file of the allocator if it is not NULL.  */
     407                 :             : FILE *ira_dump_file;
     408                 :             : 
     409                 :             : /* The number of elements in the following array.  */
     410                 :             : int ira_spilled_reg_stack_slots_num;
     411                 :             : 
     412                 :             : /* The following array contains info about spilled pseudo-registers
     413                 :             :    stack slots used in current function so far.  */
     414                 :             : class ira_spilled_reg_stack_slot *ira_spilled_reg_stack_slots;
     415                 :             : 
     416                 :             : /* Correspondingly overall cost of the allocation, overall cost before
     417                 :             :    reload, cost of the allocnos assigned to hard-registers, cost of
     418                 :             :    the allocnos assigned to memory, cost of loads, stores and register
     419                 :             :    move insns generated for pseudo-register live range splitting (see
     420                 :             :    ira-emit.cc).  */
     421                 :             : int64_t ira_overall_cost, overall_cost_before;
     422                 :             : int64_t ira_reg_cost, ira_mem_cost;
     423                 :             : int64_t ira_load_cost, ira_store_cost, ira_shuffle_cost;
     424                 :             : int ira_move_loops_num, ira_additional_jumps_num;
     425                 :             : 
     426                 :             : /* All registers that can be eliminated.  */
     427                 :             : 
     428                 :             : HARD_REG_SET eliminable_regset;
     429                 :             : 
     430                 :             : /* Value of max_reg_num () before IRA work start.  This value helps
     431                 :             :    us to recognize a situation when new pseudos were created during
     432                 :             :    IRA work.  */
     433                 :             : static int max_regno_before_ira;
     434                 :             : 
     435                 :             : /* Temporary hard reg set used for a different calculation.  */
     436                 :             : static HARD_REG_SET temp_hard_regset;
     437                 :             : 
     438                 :             : #define last_mode_for_init_move_cost \
     439                 :             :   (this_target_ira_int->x_last_mode_for_init_move_cost)
     440                 :             : 
     441                 :             : 
     442                 :             : /* The function sets up the map IRA_REG_MODE_HARD_REGSET.  */
     443                 :             : static void
     444                 :      206438 : setup_reg_mode_hard_regset (void)
     445                 :             : {
     446                 :      206438 :   int i, m, hard_regno;
     447                 :             : 
     448                 :    27043378 :   for (m = 0; m < NUM_MACHINE_MODES; m++)
     449                 :  2495835420 :     for (hard_regno = 0; hard_regno < FIRST_PSEUDO_REGISTER; hard_regno++)
     450                 :             :       {
     451                 :  2468998480 :         CLEAR_HARD_REG_SET (ira_reg_mode_hard_regset[hard_regno][m]);
     452                 :  8693675776 :         for (i = hard_regno_nregs (hard_regno, (machine_mode) m) - 1;
     453                 :  8693675776 :              i >= 0; i--)
     454                 :  6224677296 :           if (hard_regno + i < FIRST_PSEUDO_REGISTER)
     455                 :  5344058889 :             SET_HARD_REG_BIT (ira_reg_mode_hard_regset[hard_regno][m],
     456                 :             :                               hard_regno + i);
     457                 :             :       }
     458                 :      206438 : }
     459                 :             : 
     460                 :             : 
     461                 :             : #define no_unit_alloc_regs \
     462                 :             :   (this_target_ira_int->x_no_unit_alloc_regs)
     463                 :             : 
     464                 :             : /* The function sets up the three arrays declared above.  */
     465                 :             : static void
     466                 :      206438 : setup_class_hard_regs (void)
     467                 :             : {
     468                 :      206438 :   int cl, i, hard_regno, n;
     469                 :      206438 :   HARD_REG_SET processed_hard_reg_set;
     470                 :             : 
     471                 :      206438 :   ira_assert (SHRT_MAX >= FIRST_PSEUDO_REGISTER);
     472                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     473                 :             :     {
     474                 :     7018892 :       temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     475                 :     7018892 :       CLEAR_HARD_REG_SET (processed_hard_reg_set);
     476                 :   652756956 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     477                 :             :         {
     478                 :   645738064 :           ira_non_ordered_class_hard_regs[cl][i] = -1;
     479                 :   645738064 :           ira_class_hard_reg_index[cl][i] = -1;
     480                 :             :         }
     481                 :   652756956 :       for (n = 0, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     482                 :             :         {
     483                 :             : #ifdef REG_ALLOC_ORDER
     484                 :   645738064 :           hard_regno = reg_alloc_order[i];
     485                 :             : #else
     486                 :             :           hard_regno = i;
     487                 :             : #endif
     488                 :   645738064 :           if (TEST_HARD_REG_BIT (processed_hard_reg_set, hard_regno))
     489                 :    28075568 :             continue;
     490                 :   617662496 :           SET_HARD_REG_BIT (processed_hard_reg_set, hard_regno);
     491                 :   617662496 :           if (! TEST_HARD_REG_BIT (temp_hard_regset, hard_regno))
     492                 :   546559616 :             ira_class_hard_reg_index[cl][hard_regno] = -1;
     493                 :             :           else
     494                 :             :             {
     495                 :    71102880 :               ira_class_hard_reg_index[cl][hard_regno] = n;
     496                 :    71102880 :               ira_class_hard_regs[cl][n++] = hard_regno;
     497                 :             :             }
     498                 :             :         }
     499                 :     7018892 :       ira_class_hard_regs_num[cl] = n;
     500                 :   652756956 :       for (n = 0, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     501                 :   645738064 :         if (TEST_HARD_REG_BIT (temp_hard_regset, i))
     502                 :    71102880 :           ira_non_ordered_class_hard_regs[cl][n++] = i;
     503                 :     7018892 :       ira_assert (ira_class_hard_regs_num[cl] == n);
     504                 :             :     }
     505                 :      206438 : }
     506                 :             : 
     507                 :             : /* Set up global variables defining info about hard registers for the
     508                 :             :    allocation.  These depend on USE_HARD_FRAME_P whose TRUE value means
     509                 :             :    that we can use the hard frame pointer for the allocation.  */
     510                 :             : static void
     511                 :      206438 : setup_alloc_regs (bool use_hard_frame_p)
     512                 :             : {
     513                 :             : #ifdef ADJUST_REG_ALLOC_ORDER
     514                 :      206438 :   ADJUST_REG_ALLOC_ORDER;
     515                 :             : #endif
     516                 :      206438 :   no_unit_alloc_regs = fixed_nonglobal_reg_set;
     517                 :      206438 :   if (! use_hard_frame_p)
     518                 :       65158 :     add_to_hard_reg_set (&no_unit_alloc_regs, Pmode,
     519                 :             :                          HARD_FRAME_POINTER_REGNUM);
     520                 :      206438 :   setup_class_hard_regs ();
     521                 :      206438 : }
     522                 :             : 
     523                 :             : 
     524                 :             : 
     525                 :             : #define alloc_reg_class_subclasses \
     526                 :             :   (this_target_ira_int->x_alloc_reg_class_subclasses)
     527                 :             : 
     528                 :             : /* Initialize the table of subclasses of each reg class.  */
     529                 :             : static void
     530                 :      206438 : setup_reg_subclasses (void)
     531                 :             : {
     532                 :      206438 :   int i, j;
     533                 :      206438 :   HARD_REG_SET temp_hard_regset2;
     534                 :             : 
     535                 :     7225330 :   for (i = 0; i < N_REG_CLASSES; i++)
     536                 :   245661220 :     for (j = 0; j < N_REG_CLASSES; j++)
     537                 :   238642328 :       alloc_reg_class_subclasses[i][j] = LIM_REG_CLASSES;
     538                 :             : 
     539                 :     7225330 :   for (i = 0; i < N_REG_CLASSES; i++)
     540                 :             :     {
     541                 :     7018892 :       if (i == (int) NO_REGS)
     542                 :      206438 :         continue;
     543                 :             : 
     544                 :     6812454 :       temp_hard_regset = reg_class_contents[i] & ~no_unit_alloc_regs;
     545                 :    13624908 :       if (hard_reg_set_empty_p (temp_hard_regset))
     546                 :      410391 :         continue;
     547                 :   224072205 :       for (j = 0; j < N_REG_CLASSES; j++)
     548                 :   217670142 :         if (i != j)
     549                 :             :           {
     550                 :   211268079 :             enum reg_class *p;
     551                 :             : 
     552                 :   211268079 :             temp_hard_regset2 = reg_class_contents[j] & ~no_unit_alloc_regs;
     553                 :   422536158 :             if (! hard_reg_set_subset_p (temp_hard_regset,
     554                 :             :                                          temp_hard_regset2))
     555                 :   160983216 :               continue;
     556                 :    50284863 :             p = &alloc_reg_class_subclasses[j][0];
     557                 :   483676780 :             while (*p != LIM_REG_CLASSES) p++;
     558                 :    50284863 :             *p = (enum reg_class) i;
     559                 :             :           }
     560                 :             :     }
     561                 :      206438 : }
     562                 :             : 
     563                 :             : 
     564                 :             : 
     565                 :             : /* Set up IRA_MEMORY_MOVE_COST and IRA_MAX_MEMORY_MOVE_COST.  */
     566                 :             : static void
     567                 :      206438 : setup_class_subset_and_memory_move_costs (void)
     568                 :             : {
     569                 :      206438 :   int cl, cl2, mode, cost;
     570                 :      206438 :   HARD_REG_SET temp_hard_regset2;
     571                 :             : 
     572                 :    27043378 :   for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     573                 :    26836940 :     ira_memory_move_cost[mode][NO_REGS][0]
     574                 :    26836940 :       = ira_memory_move_cost[mode][NO_REGS][1] = SHRT_MAX;
     575                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     576                 :             :     {
     577                 :     7018892 :       if (cl != (int) NO_REGS)
     578                 :   892431474 :         for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     579                 :             :           {
     580                 :  1771238040 :             ira_max_memory_move_cost[mode][cl][0]
     581                 :   885619020 :               = ira_memory_move_cost[mode][cl][0]
     582                 :   885619020 :               = memory_move_cost ((machine_mode) mode,
     583                 :             :                                   (reg_class_t) cl, false);
     584                 :  1771238040 :             ira_max_memory_move_cost[mode][cl][1]
     585                 :   885619020 :               = ira_memory_move_cost[mode][cl][1]
     586                 :   885619020 :               = memory_move_cost ((machine_mode) mode,
     587                 :             :                                   (reg_class_t) cl, true);
     588                 :             :             /* Costs for NO_REGS are used in cost calculation on the
     589                 :             :                1st pass when the preferred register classes are not
     590                 :             :                known yet.  In this case we take the best scenario.  */
     591                 :   885619020 :             if (!targetm.hard_regno_mode_ok (ira_class_hard_regs[cl][0],
     592                 :             :                                              (machine_mode) mode))
     593                 :   663792208 :               continue;
     594                 :             : 
     595                 :   221826812 :             if (ira_memory_move_cost[mode][NO_REGS][0]
     596                 :   221826812 :                 > ira_memory_move_cost[mode][cl][0])
     597                 :    12468112 :               ira_max_memory_move_cost[mode][NO_REGS][0]
     598                 :    12468112 :                 = ira_memory_move_cost[mode][NO_REGS][0]
     599                 :    12468112 :                 = ira_memory_move_cost[mode][cl][0];
     600                 :   221826812 :             if (ira_memory_move_cost[mode][NO_REGS][1]
     601                 :   221826812 :                 > ira_memory_move_cost[mode][cl][1])
     602                 :    12457225 :               ira_max_memory_move_cost[mode][NO_REGS][1]
     603                 :    12457225 :                 = ira_memory_move_cost[mode][NO_REGS][1]
     604                 :    12457225 :                 = ira_memory_move_cost[mode][cl][1];
     605                 :             :           }
     606                 :             :     }
     607                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     608                 :   245661220 :     for (cl2 = (int) N_REG_CLASSES - 1; cl2 >= 0; cl2--)
     609                 :             :       {
     610                 :   238642328 :         temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     611                 :   238642328 :         temp_hard_regset2 = reg_class_contents[cl2] & ~no_unit_alloc_regs;
     612                 :   238642328 :         ira_class_subset_p[cl][cl2]
     613                 :   238642328 :           = hard_reg_set_subset_p (temp_hard_regset, temp_hard_regset2);
     614                 :   238642328 :         if (! hard_reg_set_empty_p (temp_hard_regset2)
     615                 :   456312470 :             && hard_reg_set_subset_p (reg_class_contents[cl2],
     616                 :             :                                       reg_class_contents[cl]))
     617                 :  6732171220 :           for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     618                 :             :             {
     619                 :  6680780600 :               cost = ira_memory_move_cost[mode][cl2][0];
     620                 :  6680780600 :               if (cost > ira_max_memory_move_cost[mode][cl][0])
     621                 :   109145933 :                 ira_max_memory_move_cost[mode][cl][0] = cost;
     622                 :  6680780600 :               cost = ira_memory_move_cost[mode][cl2][1];
     623                 :  6680780600 :               if (cost > ira_max_memory_move_cost[mode][cl][1])
     624                 :   109194462 :                 ira_max_memory_move_cost[mode][cl][1] = cost;
     625                 :             :             }
     626                 :             :       }
     627                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     628                 :   919474852 :     for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     629                 :             :       {
     630                 :   912455960 :         ira_memory_move_cost[mode][cl][0]
     631                 :   912455960 :           = ira_max_memory_move_cost[mode][cl][0];
     632                 :   912455960 :         ira_memory_move_cost[mode][cl][1]
     633                 :   912455960 :           = ira_max_memory_move_cost[mode][cl][1];
     634                 :             :       }
     635                 :      206438 :   setup_reg_subclasses ();
     636                 :      206438 : }
     637                 :             : 
     638                 :             : 
     639                 :             : 
     640                 :             : /* Define the following macro if allocation through malloc if
     641                 :             :    preferable.  */
     642                 :             : #define IRA_NO_OBSTACK
     643                 :             : 
     644                 :             : #ifndef IRA_NO_OBSTACK
     645                 :             : /* Obstack used for storing all dynamic data (except bitmaps) of the
     646                 :             :    IRA.  */
     647                 :             : static struct obstack ira_obstack;
     648                 :             : #endif
     649                 :             : 
     650                 :             : /* Obstack used for storing all bitmaps of the IRA.  */
     651                 :             : static struct bitmap_obstack ira_bitmap_obstack;
     652                 :             : 
     653                 :             : /* Allocate memory of size LEN for IRA data.  */
     654                 :             : void *
     655                 :   195224026 : ira_allocate (size_t len)
     656                 :             : {
     657                 :   195224026 :   void *res;
     658                 :             : 
     659                 :             : #ifndef IRA_NO_OBSTACK
     660                 :             :   res = obstack_alloc (&ira_obstack, len);
     661                 :             : #else
     662                 :   195224026 :   res = xmalloc (len);
     663                 :             : #endif
     664                 :   195224026 :   return res;
     665                 :             : }
     666                 :             : 
     667                 :             : /* Free memory ADDR allocated for IRA data.  */
     668                 :             : void
     669                 :   195224026 : ira_free (void *addr ATTRIBUTE_UNUSED)
     670                 :             : {
     671                 :             : #ifndef IRA_NO_OBSTACK
     672                 :             :   /* do nothing */
     673                 :             : #else
     674                 :   195224026 :   free (addr);
     675                 :             : #endif
     676                 :   195224026 : }
     677                 :             : 
     678                 :             : 
     679                 :             : /* Allocate and returns bitmap for IRA.  */
     680                 :             : bitmap
     681                 :     9938272 : ira_allocate_bitmap (void)
     682                 :             : {
     683                 :     9938272 :   return BITMAP_ALLOC (&ira_bitmap_obstack);
     684                 :             : }
     685                 :             : 
     686                 :             : /* Free bitmap B allocated for IRA.  */
     687                 :             : void
     688                 :     9938272 : ira_free_bitmap (bitmap b ATTRIBUTE_UNUSED)
     689                 :             : {
     690                 :             :   /* do nothing */
     691                 :     9938272 : }
     692                 :             : 
     693                 :             : 
     694                 :             : 
     695                 :             : /* Output information about allocation of all allocnos (except for
     696                 :             :    caps) into file F.  */
     697                 :             : void
     698                 :          95 : ira_print_disposition (FILE *f)
     699                 :             : {
     700                 :          95 :   int i, n, max_regno;
     701                 :          95 :   ira_allocno_t a;
     702                 :          95 :   basic_block bb;
     703                 :             : 
     704                 :          95 :   fprintf (f, "Disposition:");
     705                 :          95 :   max_regno = max_reg_num ();
     706                 :        1986 :   for (n = 0, i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
     707                 :        1796 :     for (a = ira_regno_allocno_map[i];
     708                 :        2403 :          a != NULL;
     709                 :         607 :          a = ALLOCNO_NEXT_REGNO_ALLOCNO (a))
     710                 :             :       {
     711                 :         607 :         if (n % 4 == 0)
     712                 :         180 :           fprintf (f, "\n");
     713                 :         607 :         n++;
     714                 :         607 :         fprintf (f, " %4d:r%-4d", ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
     715                 :         607 :         if ((bb = ALLOCNO_LOOP_TREE_NODE (a)->bb) != NULL)
     716                 :           0 :           fprintf (f, "b%-3d", bb->index);
     717                 :             :         else
     718                 :         607 :           fprintf (f, "l%-3d", ALLOCNO_LOOP_TREE_NODE (a)->loop_num);
     719                 :         607 :         if (ALLOCNO_HARD_REGNO (a) >= 0)
     720                 :         597 :           fprintf (f, " %3d", ALLOCNO_HARD_REGNO (a));
     721                 :             :         else
     722                 :          10 :           fprintf (f, " mem");
     723                 :             :       }
     724                 :          95 :   fprintf (f, "\n");
     725                 :          95 : }
     726                 :             : 
     727                 :             : /* Outputs information about allocation of all allocnos into
     728                 :             :    stderr.  */
     729                 :             : void
     730                 :           0 : ira_debug_disposition (void)
     731                 :             : {
     732                 :           0 :   ira_print_disposition (stderr);
     733                 :           0 : }
     734                 :             : 
     735                 :             : 
     736                 :             : 
     737                 :             : /* Set up ira_stack_reg_pressure_class which is the biggest pressure
     738                 :             :    register class containing stack registers or NO_REGS if there are
     739                 :             :    no stack registers.  To find this class, we iterate through all
     740                 :             :    register pressure classes and choose the first register pressure
     741                 :             :    class containing all the stack registers and having the biggest
     742                 :             :    size.  */
     743                 :             : static void
     744                 :      206438 : setup_stack_reg_pressure_class (void)
     745                 :             : {
     746                 :      206438 :   ira_stack_reg_pressure_class = NO_REGS;
     747                 :             : #ifdef STACK_REGS
     748                 :      206438 :   {
     749                 :      206438 :     int i, best, size;
     750                 :      206438 :     enum reg_class cl;
     751                 :      206438 :     HARD_REG_SET temp_hard_regset2;
     752                 :             : 
     753                 :      206438 :     CLEAR_HARD_REG_SET (temp_hard_regset);
     754                 :     1857942 :     for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
     755                 :     1651504 :       SET_HARD_REG_BIT (temp_hard_regset, i);
     756                 :             :     best = 0;
     757                 :     1033710 :     for (i = 0; i < ira_pressure_classes_num; i++)
     758                 :             :       {
     759                 :      827272 :         cl = ira_pressure_classes[i];
     760                 :      827272 :         temp_hard_regset2 = temp_hard_regset & reg_class_contents[cl];
     761                 :      827272 :         size = hard_reg_set_size (temp_hard_regset2);
     762                 :      827272 :         if (best < size)
     763                 :             :           {
     764                 :      205790 :             best = size;
     765                 :      205790 :             ira_stack_reg_pressure_class = cl;
     766                 :             :           }
     767                 :             :       }
     768                 :             :   }
     769                 :             : #endif
     770                 :      206438 : }
     771                 :             : 
     772                 :             : /* Find pressure classes which are register classes for which we
     773                 :             :    calculate register pressure in IRA, register pressure sensitive
     774                 :             :    insn scheduling, and register pressure sensitive loop invariant
     775                 :             :    motion.
     776                 :             : 
     777                 :             :    To make register pressure calculation easy, we always use
     778                 :             :    non-intersected register pressure classes.  A move of hard
     779                 :             :    registers from one register pressure class is not more expensive
     780                 :             :    than load and store of the hard registers.  Most likely an allocno
     781                 :             :    class will be a subset of a register pressure class and in many
     782                 :             :    cases a register pressure class.  That makes usage of register
     783                 :             :    pressure classes a good approximation to find a high register
     784                 :             :    pressure.  */
     785                 :             : static void
     786                 :      206438 : setup_pressure_classes (void)
     787                 :             : {
     788                 :      206438 :   int cost, i, n, curr;
     789                 :      206438 :   int cl, cl2;
     790                 :      206438 :   enum reg_class pressure_classes[N_REG_CLASSES];
     791                 :      206438 :   int m;
     792                 :      206438 :   HARD_REG_SET temp_hard_regset2;
     793                 :      206438 :   bool insert_p;
     794                 :             : 
     795                 :      206438 :   if (targetm.compute_pressure_classes)
     796                 :           0 :     n = targetm.compute_pressure_classes (pressure_classes);
     797                 :             :   else
     798                 :             :     { 
     799                 :             :       n = 0;
     800                 :     7225330 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
     801                 :             :         {
     802                 :     7018892 :           if (ira_class_hard_regs_num[cl] == 0)
     803                 :      616829 :             continue;
     804                 :     6402063 :           if (ira_class_hard_regs_num[cl] != 1
     805                 :             :               /* A register class without subclasses may contain a few
     806                 :             :                  hard registers and movement between them is costly
     807                 :             :                  (e.g. SPARC FPCC registers).  We still should consider it
     808                 :             :                  as a candidate for a pressure class.  */
     809                 :     4546121 :               && alloc_reg_class_subclasses[cl][0] < cl)
     810                 :             :             {
     811                 :             :               /* Check that the moves between any hard registers of the
     812                 :             :                  current class are not more expensive for a legal mode
     813                 :             :                  than load/store of the hard registers of the current
     814                 :             :                  class.  Such class is a potential candidate to be a
     815                 :             :                  register pressure class.  */
     816                 :   218548596 :               for (m = 0; m < NUM_MACHINE_MODES; m++)
     817                 :             :                 {
     818                 :   217310610 :                   temp_hard_regset
     819                 :   217310610 :                     = (reg_class_contents[cl]
     820                 :   217310610 :                        & ~(no_unit_alloc_regs
     821                 :   217310610 :                            | ira_prohibited_class_mode_regs[cl][m]));
     822                 :   434621220 :                   if (hard_reg_set_empty_p (temp_hard_regset))
     823                 :   162569585 :                     continue;
     824                 :    54741025 :                   ira_init_register_move_cost_if_necessary ((machine_mode) m);
     825                 :    54741025 :                   cost = ira_register_move_cost[m][cl][cl];
     826                 :    54741025 :                   if (cost <= ira_max_memory_move_cost[m][cl][1]
     827                 :    51642200 :                       || cost <= ira_max_memory_move_cost[m][cl][0])
     828                 :             :                     break;
     829                 :             :                 }
     830                 :     4336811 :               if (m >= NUM_MACHINE_MODES)
     831                 :     1237986 :                 continue;
     832                 :             :             }
     833                 :     5164077 :           curr = 0;
     834                 :     5164077 :           insert_p = true;
     835                 :     5164077 :           temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     836                 :             :           /* Remove so far added pressure classes which are subset of the
     837                 :             :              current candidate class.  Prefer GENERAL_REGS as a pressure
     838                 :             :              register class to another class containing the same
     839                 :             :              allocatable hard registers.  We do this because machine
     840                 :             :              dependent cost hooks might give wrong costs for the latter
     841                 :             :              class but always give the right cost for the former class
     842                 :             :              (GENERAL_REGS).  */
     843                 :    18530391 :           for (i = 0; i < n; i++)
     844                 :             :             {
     845                 :    13366314 :               cl2 = pressure_classes[i];
     846                 :    13366314 :               temp_hard_regset2 = (reg_class_contents[cl2]
     847                 :    13366314 :                                    & ~no_unit_alloc_regs);
     848                 :    13366314 :               if (hard_reg_set_subset_p (temp_hard_regset, temp_hard_regset2)
     849                 :    14468471 :                   && (temp_hard_regset != temp_hard_regset2
     850                 :     1037260 :                       || cl2 == (int) GENERAL_REGS))
     851                 :             :                 {
     852                 :      684110 :                   pressure_classes[curr++] = (enum reg_class) cl2;
     853                 :      684110 :                   insert_p = false;
     854                 :      684110 :                   continue;
     855                 :             :                 }
     856                 :    15922296 :               if (hard_reg_set_subset_p (temp_hard_regset2, temp_hard_regset)
     857                 :    16334899 :                   && (temp_hard_regset2 != temp_hard_regset
     858                 :      418047 :                       || cl == (int) GENERAL_REGS))
     859                 :     3240092 :                 continue;
     860                 :     9442112 :               if (temp_hard_regset2 == temp_hard_regset)
     861                 :      412603 :                 insert_p = false;
     862                 :     9442112 :               pressure_classes[curr++] = (enum reg_class) cl2;
     863                 :             :             }
     864                 :             :           /* If the current candidate is a subset of a so far added
     865                 :             :              pressure class, don't add it to the list of the pressure
     866                 :             :              classes.  */
     867                 :     5164077 :           if (insert_p)
     868                 :     4067364 :             pressure_classes[curr++] = (enum reg_class) cl;
     869                 :             :           n = curr;
     870                 :             :         }
     871                 :             :     }
     872                 :             : #ifdef ENABLE_IRA_CHECKING
     873                 :      206438 :   {
     874                 :      206438 :     HARD_REG_SET ignore_hard_regs;
     875                 :             : 
     876                 :             :     /* Check pressure classes correctness: here we check that hard
     877                 :             :        registers from all register pressure classes contains all hard
     878                 :             :        registers available for the allocation.  */
     879                 :      825752 :     CLEAR_HARD_REG_SET (temp_hard_regset);
     880                 :      206438 :     CLEAR_HARD_REG_SET (temp_hard_regset2);
     881                 :      206438 :     ignore_hard_regs = no_unit_alloc_regs;
     882                 :     7225330 :     for (cl = 0; cl < LIM_REG_CLASSES; cl++)
     883                 :             :       {
     884                 :             :         /* For some targets (like MIPS with MD_REGS), there are some
     885                 :             :            classes with hard registers available for allocation but
     886                 :             :            not able to hold value of any mode.  */
     887                 :   203198243 :         for (m = 0; m < NUM_MACHINE_MODES; m++)
     888                 :   202581414 :           if (contains_reg_of_mode[cl][m])
     889                 :             :             break;
     890                 :     7018892 :         if (m >= NUM_MACHINE_MODES)
     891                 :             :           {
     892                 :      616829 :             ignore_hard_regs |= reg_class_contents[cl];
     893                 :      616829 :             continue;
     894                 :             :           }
     895                 :    30009226 :         for (i = 0; i < n; i++)
     896                 :    24434435 :           if ((int) pressure_classes[i] == cl)
     897                 :             :             break;
     898                 :     6402063 :         temp_hard_regset2 |= reg_class_contents[cl];
     899                 :     6402063 :         if (i < n)
     900                 :     7018892 :           temp_hard_regset |= reg_class_contents[cl];
     901                 :             :       }
     902                 :    19198734 :     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     903                 :             :       /* Some targets (like SPARC with ICC reg) have allocatable regs
     904                 :             :          for which no reg class is defined.  */
     905                 :    18992296 :       if (REGNO_REG_CLASS (i) == NO_REGS)
     906                 :      412876 :         SET_HARD_REG_BIT (ignore_hard_regs, i);
     907                 :      206438 :     temp_hard_regset &= ~ignore_hard_regs;
     908                 :      206438 :     temp_hard_regset2 &= ~ignore_hard_regs;
     909                 :      412876 :     ira_assert (hard_reg_set_subset_p (temp_hard_regset2, temp_hard_regset));
     910                 :             :   }
     911                 :             : #endif
     912                 :      206438 :   ira_pressure_classes_num = 0;
     913                 :     1033710 :   for (i = 0; i < n; i++)
     914                 :             :     {
     915                 :      827272 :       cl = (int) pressure_classes[i];
     916                 :      827272 :       ira_reg_pressure_class_p[cl] = true;
     917                 :      827272 :       ira_pressure_classes[ira_pressure_classes_num++] = (enum reg_class) cl;
     918                 :             :     }
     919                 :      206438 :   setup_stack_reg_pressure_class ();
     920                 :      206438 : }
     921                 :             : 
     922                 :             : /* Set up IRA_UNIFORM_CLASS_P.  Uniform class is a register class
     923                 :             :    whose register move cost between any registers of the class is the
     924                 :             :    same as for all its subclasses.  We use the data to speed up the
     925                 :             :    2nd pass of calculations of allocno costs.  */
     926                 :             : static void
     927                 :      206438 : setup_uniform_class_p (void)
     928                 :             : {
     929                 :      206438 :   int i, cl, cl2, m;
     930                 :             : 
     931                 :     7225330 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
     932                 :             :     {
     933                 :     7018892 :       ira_uniform_class_p[cl] = false;
     934                 :     7018892 :       if (ira_class_hard_regs_num[cl] == 0)
     935                 :      616829 :         continue;
     936                 :             :       /* We cannot use alloc_reg_class_subclasses here because move
     937                 :             :          cost hooks does not take into account that some registers are
     938                 :             :          unavailable for the subtarget.  E.g. for i686, INT_SSE_REGS
     939                 :             :          is element of alloc_reg_class_subclasses for GENERAL_REGS
     940                 :             :          because SSE regs are unavailable.  */
     941                 :    24969336 :       for (i = 0; (cl2 = reg_class_subclasses[cl][i]) != LIM_REG_CLASSES; i++)
     942                 :             :         {
     943                 :    19805260 :           if (ira_class_hard_regs_num[cl2] == 0)
     944                 :         340 :             continue;
     945                 :  2458249723 :           for (m = 0; m < NUM_MACHINE_MODES; m++)
     946                 :  2439682790 :             if (contains_reg_of_mode[cl][m] && contains_reg_of_mode[cl2][m])
     947                 :             :               {
     948                 :   559314550 :                 ira_init_register_move_cost_if_necessary ((machine_mode) m);
     949                 :   559314550 :                 if (ira_register_move_cost[m][cl][cl]
     950                 :   559314550 :                     != ira_register_move_cost[m][cl2][cl2])
     951                 :             :                   break;
     952                 :             :               }
     953                 :    19804920 :           if (m < NUM_MACHINE_MODES)
     954                 :             :             break;
     955                 :             :         }
     956                 :     6402063 :       if (cl2 == LIM_REG_CLASSES)
     957                 :     5164076 :         ira_uniform_class_p[cl] = true;
     958                 :             :     }
     959                 :      206438 : }
     960                 :             : 
     961                 :             : /* Set up IRA_ALLOCNO_CLASSES, IRA_ALLOCNO_CLASSES_NUM,
     962                 :             :    IRA_IMPORTANT_CLASSES, and IRA_IMPORTANT_CLASSES_NUM.
     963                 :             : 
     964                 :             :    Target may have many subtargets and not all target hard registers can
     965                 :             :    be used for allocation, e.g. x86 port in 32-bit mode cannot use
     966                 :             :    hard registers introduced in x86-64 like r8-r15).  Some classes
     967                 :             :    might have the same allocatable hard registers, e.g.  INDEX_REGS
     968                 :             :    and GENERAL_REGS in x86 port in 32-bit mode.  To decrease different
     969                 :             :    calculations efforts we introduce allocno classes which contain
     970                 :             :    unique non-empty sets of allocatable hard-registers.
     971                 :             : 
     972                 :             :    Pseudo class cost calculation in ira-costs.cc is very expensive.
     973                 :             :    Therefore we are trying to decrease number of classes involved in
     974                 :             :    such calculation.  Register classes used in the cost calculation
     975                 :             :    are called important classes.  They are allocno classes and other
     976                 :             :    non-empty classes whose allocatable hard register sets are inside
     977                 :             :    of an allocno class hard register set.  From the first sight, it
     978                 :             :    looks like that they are just allocno classes.  It is not true.  In
     979                 :             :    example of x86-port in 32-bit mode, allocno classes will contain
     980                 :             :    GENERAL_REGS but not LEGACY_REGS (because allocatable hard
     981                 :             :    registers are the same for the both classes).  The important
     982                 :             :    classes will contain GENERAL_REGS and LEGACY_REGS.  It is done
     983                 :             :    because a machine description insn constraint may refers for
     984                 :             :    LEGACY_REGS and code in ira-costs.cc is mostly base on investigation
     985                 :             :    of the insn constraints.  */
     986                 :             : static void
     987                 :      206438 : setup_allocno_and_important_classes (void)
     988                 :             : {
     989                 :      206438 :   int i, j, n, cl;
     990                 :      206438 :   bool set_p;
     991                 :      206438 :   HARD_REG_SET temp_hard_regset2;
     992                 :      206438 :   static enum reg_class classes[LIM_REG_CLASSES + 1];
     993                 :             : 
     994                 :      206438 :   n = 0;
     995                 :             :   /* Collect classes which contain unique sets of allocatable hard
     996                 :             :      registers.  Prefer GENERAL_REGS to other classes containing the
     997                 :             :      same set of hard registers.  */
     998                 :     7225330 :   for (i = 0; i < LIM_REG_CLASSES; i++)
     999                 :             :     {
    1000                 :     7018892 :       temp_hard_regset = reg_class_contents[i] & ~no_unit_alloc_regs;
    1001                 :    91320791 :       for (j = 0; j < n; j++)
    1002                 :             :         {
    1003                 :    85955295 :           cl = classes[j];
    1004                 :    85955295 :           temp_hard_regset2 = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1005                 :   171910590 :           if (temp_hard_regset == temp_hard_regset2)
    1006                 :             :             break;
    1007                 :             :         }
    1008                 :     7018892 :       if (j >= n || targetm.additional_allocno_class_p (i))
    1009                 :     5365496 :         classes[n++] = (enum reg_class) i;
    1010                 :     1653396 :       else if (i == GENERAL_REGS)
    1011                 :             :         /* Prefer general regs.  For i386 example, it means that
    1012                 :             :            we prefer GENERAL_REGS over INDEX_REGS or LEGACY_REGS
    1013                 :             :            (all of them consists of the same available hard
    1014                 :             :            registers).  */
    1015                 :        5444 :         classes[j] = (enum reg_class) i;
    1016                 :             :     }
    1017                 :      206438 :   classes[n] = LIM_REG_CLASSES;
    1018                 :             : 
    1019                 :             :   /* Set up classes which can be used for allocnos as classes
    1020                 :             :      containing non-empty unique sets of allocatable hard
    1021                 :             :      registers.  */
    1022                 :      206438 :   ira_allocno_classes_num = 0;
    1023                 :     5571934 :   for (i = 0; (cl = classes[i]) != LIM_REG_CLASSES; i++)
    1024                 :     5365496 :     if (ira_class_hard_regs_num[cl] > 0)
    1025                 :     5159058 :       ira_allocno_classes[ira_allocno_classes_num++] = (enum reg_class) cl;
    1026                 :      206438 :   ira_important_classes_num = 0;
    1027                 :             :   /* Add non-allocno classes containing to non-empty set of
    1028                 :             :      allocatable hard regs.  */
    1029                 :     7225330 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1030                 :     7018892 :     if (ira_class_hard_regs_num[cl] > 0)
    1031                 :             :       {
    1032                 :     6402063 :         temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1033                 :     6402063 :         set_p = false;
    1034                 :    99363612 :         for (j = 0; j < ira_allocno_classes_num; j++)
    1035                 :             :           {
    1036                 :    98120607 :             temp_hard_regset2 = (reg_class_contents[ira_allocno_classes[j]]
    1037                 :    98120607 :                                  & ~no_unit_alloc_regs);
    1038                 :    98120607 :             if ((enum reg_class) cl == ira_allocno_classes[j])
    1039                 :             :               break;
    1040                 :    92961549 :             else if (hard_reg_set_subset_p (temp_hard_regset,
    1041                 :             :                                             temp_hard_regset2))
    1042                 :     6461649 :               set_p = true;
    1043                 :             :           }
    1044                 :     6402063 :         if (set_p && j >= ira_allocno_classes_num)
    1045                 :     1243005 :           ira_important_classes[ira_important_classes_num++]
    1046                 :     1243005 :             = (enum reg_class) cl;
    1047                 :             :       }
    1048                 :             :   /* Now add allocno classes to the important classes.  */
    1049                 :     5365496 :   for (j = 0; j < ira_allocno_classes_num; j++)
    1050                 :     5159058 :     ira_important_classes[ira_important_classes_num++]
    1051                 :     5159058 :       = ira_allocno_classes[j];
    1052                 :     7225330 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1053                 :             :     {
    1054                 :     7018892 :       ira_reg_allocno_class_p[cl] = false;
    1055                 :     7018892 :       ira_reg_pressure_class_p[cl] = false;
    1056                 :             :     }
    1057                 :     5365496 :   for (j = 0; j < ira_allocno_classes_num; j++)
    1058                 :     5159058 :     ira_reg_allocno_class_p[ira_allocno_classes[j]] = true;
    1059                 :      206438 :   setup_pressure_classes ();
    1060                 :      206438 :   setup_uniform_class_p ();
    1061                 :      206438 : }
    1062                 :             : 
    1063                 :             : /* Setup translation in CLASS_TRANSLATE of all classes into a class
    1064                 :             :    given by array CLASSES of length CLASSES_NUM.  The function is used
    1065                 :             :    make translation any reg class to an allocno class or to an
    1066                 :             :    pressure class.  This translation is necessary for some
    1067                 :             :    calculations when we can use only allocno or pressure classes and
    1068                 :             :    such translation represents an approximate representation of all
    1069                 :             :    classes.
    1070                 :             : 
    1071                 :             :    The translation in case when allocatable hard register set of a
    1072                 :             :    given class is subset of allocatable hard register set of a class
    1073                 :             :    in CLASSES is pretty simple.  We use smallest classes from CLASSES
    1074                 :             :    containing a given class.  If allocatable hard register set of a
    1075                 :             :    given class is not a subset of any corresponding set of a class
    1076                 :             :    from CLASSES, we use the cheapest (with load/store point of view)
    1077                 :             :    class from CLASSES whose set intersects with given class set.  */
    1078                 :             : static void
    1079                 :      412876 : setup_class_translate_array (enum reg_class *class_translate,
    1080                 :             :                              int classes_num, enum reg_class *classes)
    1081                 :             : {
    1082                 :      412876 :   int cl, mode;
    1083                 :      412876 :   enum reg_class aclass, best_class, *cl_ptr;
    1084                 :      412876 :   int i, cost, min_cost, best_cost;
    1085                 :             : 
    1086                 :    14450660 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1087                 :    14037784 :     class_translate[cl] = NO_REGS;
    1088                 :             : 
    1089                 :     6399206 :   for (i = 0; i < classes_num; i++)
    1090                 :             :     {
    1091                 :     5986330 :       aclass = classes[i];
    1092                 :    43951113 :       for (cl_ptr = &alloc_reg_class_subclasses[aclass][0];
    1093                 :    43951113 :            (cl = *cl_ptr) != LIM_REG_CLASSES;
    1094                 :             :            cl_ptr++)
    1095                 :    37964783 :         if (class_translate[cl] == NO_REGS)
    1096                 :     5848748 :           class_translate[cl] = aclass;
    1097                 :     5986330 :       class_translate[aclass] = aclass;
    1098                 :             :     }
    1099                 :             :   /* For classes which are not fully covered by one of given classes
    1100                 :             :      (in other words covered by more one given class), use the
    1101                 :             :      cheapest class.  */
    1102                 :    14450660 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1103                 :             :     {
    1104                 :    14037784 :       if (cl == NO_REGS || class_translate[cl] != NO_REGS)
    1105                 :    12183114 :         continue;
    1106                 :             :       best_class = NO_REGS;
    1107                 :             :       best_cost = INT_MAX;
    1108                 :    17769604 :       for (i = 0; i < classes_num; i++)
    1109                 :             :         {
    1110                 :    15914934 :           aclass = classes[i];
    1111                 :    15914934 :           temp_hard_regset = (reg_class_contents[aclass]
    1112                 :    15914934 :                               & reg_class_contents[cl]
    1113                 :    15914934 :                               & ~no_unit_alloc_regs);
    1114                 :    31829868 :           if (! hard_reg_set_empty_p (temp_hard_regset))
    1115                 :             :             {
    1116                 :             :               min_cost = INT_MAX;
    1117                 :   352199264 :               for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
    1118                 :             :                 {
    1119                 :   349510720 :                   cost = (ira_memory_move_cost[mode][aclass][0]
    1120                 :   349510720 :                           + ira_memory_move_cost[mode][aclass][1]);
    1121                 :   349510720 :                   if (min_cost > cost)
    1122                 :             :                     min_cost = cost;
    1123                 :             :                 }
    1124                 :     2688544 :               if (best_class == NO_REGS || best_cost > min_cost)
    1125                 :             :                 {
    1126                 :    15914934 :                   best_class = aclass;
    1127                 :    15914934 :                   best_cost = min_cost;
    1128                 :             :                 }
    1129                 :             :             }
    1130                 :             :         }
    1131                 :     1854670 :       class_translate[cl] = best_class;
    1132                 :             :     }
    1133                 :      412876 : }
    1134                 :             : 
    1135                 :             : /* Set up array IRA_ALLOCNO_CLASS_TRANSLATE and
    1136                 :             :    IRA_PRESSURE_CLASS_TRANSLATE.  */
    1137                 :             : static void
    1138                 :      206438 : setup_class_translate (void)
    1139                 :             : {
    1140                 :      206438 :   setup_class_translate_array (ira_allocno_class_translate,
    1141                 :      206438 :                                ira_allocno_classes_num, ira_allocno_classes);
    1142                 :      206438 :   setup_class_translate_array (ira_pressure_class_translate,
    1143                 :      206438 :                                ira_pressure_classes_num, ira_pressure_classes);
    1144                 :      206438 : }
    1145                 :             : 
    1146                 :             : /* Order numbers of allocno classes in original target allocno class
    1147                 :             :    array, -1 for non-allocno classes.  */
    1148                 :             : static int allocno_class_order[N_REG_CLASSES];
    1149                 :             : 
    1150                 :             : /* The function used to sort the important classes.  */
    1151                 :             : static int
    1152                 :   172079075 : comp_reg_classes_func (const void *v1p, const void *v2p)
    1153                 :             : {
    1154                 :   172079075 :   enum reg_class cl1 = *(const enum reg_class *) v1p;
    1155                 :   172079075 :   enum reg_class cl2 = *(const enum reg_class *) v2p;
    1156                 :   172079075 :   enum reg_class tcl1, tcl2;
    1157                 :   172079075 :   int diff;
    1158                 :             : 
    1159                 :   172079075 :   tcl1 = ira_allocno_class_translate[cl1];
    1160                 :   172079075 :   tcl2 = ira_allocno_class_translate[cl2];
    1161                 :   172079075 :   if (tcl1 != NO_REGS && tcl2 != NO_REGS
    1162                 :   172079075 :       && (diff = allocno_class_order[tcl1] - allocno_class_order[tcl2]) != 0)
    1163                 :             :     return diff;
    1164                 :     7804168 :   return (int) cl1 - (int) cl2;
    1165                 :             : }
    1166                 :             : 
    1167                 :             : /* For correct work of function setup_reg_class_relation we need to
    1168                 :             :    reorder important classes according to the order of their allocno
    1169                 :             :    classes.  It places important classes containing the same
    1170                 :             :    allocatable hard register set adjacent to each other and allocno
    1171                 :             :    class with the allocatable hard register set right after the other
    1172                 :             :    important classes with the same set.
    1173                 :             : 
    1174                 :             :    In example from comments of function
    1175                 :             :    setup_allocno_and_important_classes, it places LEGACY_REGS and
    1176                 :             :    GENERAL_REGS close to each other and GENERAL_REGS is after
    1177                 :             :    LEGACY_REGS.  */
    1178                 :             : static void
    1179                 :      206438 : reorder_important_classes (void)
    1180                 :             : {
    1181                 :      206438 :   int i;
    1182                 :             : 
    1183                 :     7225330 :   for (i = 0; i < N_REG_CLASSES; i++)
    1184                 :     7018892 :     allocno_class_order[i] = -1;
    1185                 :     5365496 :   for (i = 0; i < ira_allocno_classes_num; i++)
    1186                 :     5159058 :     allocno_class_order[ira_allocno_classes[i]] = i;
    1187                 :      206438 :   qsort (ira_important_classes, ira_important_classes_num,
    1188                 :             :          sizeof (enum reg_class), comp_reg_classes_func);
    1189                 :     6814939 :   for (i = 0; i < ira_important_classes_num; i++)
    1190                 :     6402063 :     ira_important_class_nums[ira_important_classes[i]] = i;
    1191                 :      206438 : }
    1192                 :             : 
    1193                 :             : /* Set up IRA_REG_CLASS_SUBUNION, IRA_REG_CLASS_SUPERUNION,
    1194                 :             :    IRA_REG_CLASS_SUPER_CLASSES, IRA_REG_CLASSES_INTERSECT, and
    1195                 :             :    IRA_REG_CLASSES_INTERSECT_P.  For the meaning of the relations,
    1196                 :             :    please see corresponding comments in ira-int.h.  */
    1197                 :             : static void
    1198                 :      206438 : setup_reg_class_relations (void)
    1199                 :             : {
    1200                 :      206438 :   int i, cl1, cl2, cl3;
    1201                 :      206438 :   HARD_REG_SET intersection_set, union_set, temp_set2;
    1202                 :      206438 :   bool important_class_p[N_REG_CLASSES];
    1203                 :             : 
    1204                 :      206438 :   memset (important_class_p, 0, sizeof (important_class_p));
    1205                 :     6608501 :   for (i = 0; i < ira_important_classes_num; i++)
    1206                 :     6402063 :     important_class_p[ira_important_classes[i]] = true;
    1207                 :     7225330 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1208                 :             :     {
    1209                 :     7018892 :       ira_reg_class_super_classes[cl1][0] = LIM_REG_CLASSES;
    1210                 :   245661220 :       for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1211                 :             :         {
    1212                 :   238642328 :           ira_reg_classes_intersect_p[cl1][cl2] = false;
    1213                 :   238642328 :           ira_reg_class_intersect[cl1][cl2] = NO_REGS;
    1214                 :   238642328 :           ira_reg_class_subset[cl1][cl2] = NO_REGS;
    1215                 :   238642328 :           temp_hard_regset = reg_class_contents[cl1] & ~no_unit_alloc_regs;
    1216                 :   238642328 :           temp_set2 = reg_class_contents[cl2] & ~no_unit_alloc_regs;
    1217                 :   238642328 :           if (hard_reg_set_empty_p (temp_hard_regset)
    1218                 :   259614514 :               && hard_reg_set_empty_p (temp_set2))
    1219                 :             :             {
    1220                 :             :               /* The both classes have no allocatable hard registers
    1221                 :             :                  -- take all class hard registers into account and use
    1222                 :             :                  reg_class_subunion and reg_class_superunion.  */
    1223                 :      730160 :               for (i = 0;; i++)
    1224                 :             :                 {
    1225                 :     2648101 :                   cl3 = reg_class_subclasses[cl1][i];
    1226                 :     2648101 :                   if (cl3 == LIM_REG_CLASSES)
    1227                 :             :                     break;
    1228                 :      730160 :                   if (reg_class_subset_p (ira_reg_class_intersect[cl1][cl2],
    1229                 :             :                                           (enum reg_class) cl3))
    1230                 :      683769 :                     ira_reg_class_intersect[cl1][cl2] = (enum reg_class) cl3;
    1231                 :             :                 }
    1232                 :     1917941 :               ira_reg_class_subunion[cl1][cl2] = reg_class_subunion[cl1][cl2];
    1233                 :     1917941 :               ira_reg_class_superunion[cl1][cl2] = reg_class_superunion[cl1][cl2];
    1234                 :     1917941 :               continue;
    1235                 :             :             }
    1236                 :             :           ira_reg_classes_intersect_p[cl1][cl2]
    1237                 :   236724387 :             = hard_reg_set_intersect_p (temp_hard_regset, temp_set2);
    1238                 :   217670142 :           if (important_class_p[cl1] && important_class_p[cl2]
    1239                 :   435340284 :               && hard_reg_set_subset_p (temp_hard_regset, temp_set2))
    1240                 :             :             {
    1241                 :             :               /* CL1 and CL2 are important classes and CL1 allocatable
    1242                 :             :                  hard register set is inside of CL2 allocatable hard
    1243                 :             :                  registers -- make CL1 a superset of CL2.  */
    1244                 :    56686926 :               enum reg_class *p;
    1245                 :             : 
    1246                 :    56686926 :               p = &ira_reg_class_super_classes[cl1][0];
    1247                 :   342142880 :               while (*p != LIM_REG_CLASSES)
    1248                 :   285455954 :                 p++;
    1249                 :    56686926 :               *p++ = (enum reg_class) cl2;
    1250                 :    56686926 :               *p = LIM_REG_CLASSES;
    1251                 :             :             }
    1252                 :   236724387 :           ira_reg_class_subunion[cl1][cl2] = NO_REGS;
    1253                 :   236724387 :           ira_reg_class_superunion[cl1][cl2] = NO_REGS;
    1254                 :   236724387 :           intersection_set = (reg_class_contents[cl1]
    1255                 :   236724387 :                               & reg_class_contents[cl2]
    1256                 :   236724387 :                               & ~no_unit_alloc_regs);
    1257                 :   236724387 :           union_set = ((reg_class_contents[cl1] | reg_class_contents[cl2])
    1258                 :   236724387 :                        & ~no_unit_alloc_regs);
    1259                 :  8285353545 :           for (cl3 = 0; cl3 < N_REG_CLASSES; cl3++)
    1260                 :             :             {
    1261                 :  8048629158 :               temp_hard_regset = reg_class_contents[cl3] & ~no_unit_alloc_regs;
    1262                 : 16097258316 :               if (hard_reg_set_empty_p (temp_hard_regset))
    1263                 :   706438251 :                 continue;
    1264                 :             : 
    1265                 :  7342190907 :               if (hard_reg_set_subset_p (temp_hard_regset, intersection_set))
    1266                 :             :                 {
    1267                 :             :                   /* CL3 allocatable hard register set is inside of
    1268                 :             :                      intersection of allocatable hard register sets
    1269                 :             :                      of CL1 and CL2.  */
    1270                 :   627598834 :                   if (important_class_p[cl3])
    1271                 :             :                     {
    1272                 :   627598834 :                       temp_set2
    1273                 :   627598834 :                         = (reg_class_contents
    1274                 :   627598834 :                            [ira_reg_class_intersect[cl1][cl2]]);
    1275                 :   627598834 :                       temp_set2 &= ~no_unit_alloc_regs;
    1276                 :   627598834 :                       if (! hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1277                 :             :                           /* If the allocatable hard register sets are
    1278                 :             :                              the same, prefer GENERAL_REGS or the
    1279                 :             :                              smallest class for debugging
    1280                 :             :                              purposes.  */
    1281                 :   729596675 :                           || (temp_hard_regset == temp_set2
    1282                 :    97950363 :                               && (cl3 == GENERAL_REGS
    1283                 :    97291633 :                                   || ((ira_reg_class_intersect[cl1][cl2]
    1284                 :             :                                        != GENERAL_REGS)
    1285                 :    32552944 :                                       && hard_reg_set_subset_p
    1286                 :    32552944 :                                          (reg_class_contents[cl3],
    1287                 :             :                                           reg_class_contents
    1288                 :             :                                           [(int)
    1289                 :             :                                            ira_reg_class_intersect[cl1][cl2]])))))
    1290                 :   551239994 :                         ira_reg_class_intersect[cl1][cl2] = (enum reg_class) cl3;
    1291                 :             :                     }
    1292                 :   627598834 :                   temp_set2
    1293                 :   627598834 :                     = (reg_class_contents[ira_reg_class_subset[cl1][cl2]]
    1294                 :   627598834 :                        & ~no_unit_alloc_regs);
    1295                 :   627598834 :                   if (! hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1296                 :             :                       /* Ignore unavailable hard registers and prefer
    1297                 :             :                          smallest class for debugging purposes.  */
    1298                 :   729596675 :                       || (temp_hard_regset == temp_set2
    1299                 :    97950363 :                           && hard_reg_set_subset_p
    1300                 :    97950363 :                              (reg_class_contents[cl3],
    1301                 :             :                               reg_class_contents
    1302                 :             :                               [(int) ira_reg_class_subset[cl1][cl2]])))
    1303                 :   583136529 :                     ira_reg_class_subset[cl1][cl2] = (enum reg_class) cl3;
    1304                 :             :                 }
    1305                 :  7342190907 :               if (important_class_p[cl3]
    1306                 : 14684381814 :                   && hard_reg_set_subset_p (temp_hard_regset, union_set))
    1307                 :             :                 {
    1308                 :             :                   /* CL3 allocatable hard register set is inside of
    1309                 :             :                      union of allocatable hard register sets of CL1
    1310                 :             :                      and CL2.  */
    1311                 :  3268724816 :                   temp_set2
    1312                 :  3268724816 :                     = (reg_class_contents[ira_reg_class_subunion[cl1][cl2]]
    1313                 :  3268724816 :                        & ~no_unit_alloc_regs);
    1314                 :  3268724816 :                   if (ira_reg_class_subunion[cl1][cl2] == NO_REGS
    1315                 :  6300725245 :                       || (hard_reg_set_subset_p (temp_set2, temp_hard_regset)
    1316                 :             :                           
    1317                 :  1009740347 :                           && (temp_set2 != temp_hard_regset
    1318                 :   420716993 :                               || cl3 == GENERAL_REGS
    1319                 :             :                               /* If the allocatable hard register sets are the
    1320                 :             :                                  same, prefer GENERAL_REGS or the smallest
    1321                 :             :                                  class for debugging purposes.  */
    1322                 :   417249201 :                               || (ira_reg_class_subunion[cl1][cl2] != GENERAL_REGS
    1323                 :    27789473 :                                   && hard_reg_set_subset_p
    1324                 :    27789473 :                                      (reg_class_contents[cl3],
    1325                 :             :                                       reg_class_contents
    1326                 :             :                                       [(int) ira_reg_class_subunion[cl1][cl2]])))))
    1327                 :   850856342 :                     ira_reg_class_subunion[cl1][cl2] = (enum reg_class) cl3;
    1328                 :             :                 }
    1329                 : 14684381814 :               if (hard_reg_set_subset_p (union_set, temp_hard_regset))
    1330                 :             :                 {
    1331                 :             :                   /* CL3 allocatable hard register set contains union
    1332                 :             :                      of allocatable hard register sets of CL1 and
    1333                 :             :                      CL2.  */
    1334                 :  1362552976 :                   temp_set2
    1335                 :  1362552976 :                     = (reg_class_contents[ira_reg_class_superunion[cl1][cl2]]
    1336                 :  1362552976 :                        & ~no_unit_alloc_regs);
    1337                 :  1362552976 :                   if (ira_reg_class_superunion[cl1][cl2] == NO_REGS
    1338                 :  2488381565 :                       || (hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1339                 :             : 
    1340                 :   193839482 :                           && (temp_set2 != temp_hard_regset
    1341                 :   192990534 :                               || cl3 == GENERAL_REGS
    1342                 :             :                               /* If the allocatable hard register sets are the
    1343                 :             :                                  same, prefer GENERAL_REGS or the smallest
    1344                 :             :                                  class for debugging purposes.  */
    1345                 :   191483694 :                               || (ira_reg_class_superunion[cl1][cl2] != GENERAL_REGS
    1346                 :    19072528 :                                   && hard_reg_set_subset_p
    1347                 :    19072528 :                                      (reg_class_contents[cl3],
    1348                 :             :                                       reg_class_contents
    1349                 :             :                                       [(int) ira_reg_class_superunion[cl1][cl2]])))))
    1350                 :   252788476 :                     ira_reg_class_superunion[cl1][cl2] = (enum reg_class) cl3;
    1351                 :             :                 }
    1352                 :             :             }
    1353                 :             :         }
    1354                 :             :     }
    1355                 :      206438 : }
    1356                 :             : 
    1357                 :             : /* Output all uniform and important classes into file F.  */
    1358                 :             : static void
    1359                 :           0 : print_uniform_and_important_classes (FILE *f)
    1360                 :             : {
    1361                 :           0 :   int i, cl;
    1362                 :             : 
    1363                 :           0 :   fprintf (f, "Uniform classes:\n");
    1364                 :           0 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1365                 :           0 :     if (ira_uniform_class_p[cl])
    1366                 :           0 :       fprintf (f, " %s", reg_class_names[cl]);
    1367                 :           0 :   fprintf (f, "\nImportant classes:\n");
    1368                 :           0 :   for (i = 0; i < ira_important_classes_num; i++)
    1369                 :           0 :     fprintf (f, " %s", reg_class_names[ira_important_classes[i]]);
    1370                 :           0 :   fprintf (f, "\n");
    1371                 :           0 : }
    1372                 :             : 
    1373                 :             : /* Output all possible allocno or pressure classes and their
    1374                 :             :    translation map into file F.  */
    1375                 :             : static void
    1376                 :           0 : print_translated_classes (FILE *f, bool pressure_p)
    1377                 :             : {
    1378                 :           0 :   int classes_num = (pressure_p
    1379                 :           0 :                      ? ira_pressure_classes_num : ira_allocno_classes_num);
    1380                 :           0 :   enum reg_class *classes = (pressure_p
    1381                 :           0 :                              ? ira_pressure_classes : ira_allocno_classes);
    1382                 :           0 :   enum reg_class *class_translate = (pressure_p
    1383                 :           0 :                                      ? ira_pressure_class_translate
    1384                 :           0 :                                      : ira_allocno_class_translate);
    1385                 :           0 :   int i;
    1386                 :             : 
    1387                 :           0 :   fprintf (f, "%s classes:\n", pressure_p ? "Pressure" : "Allocno");
    1388                 :           0 :   for (i = 0; i < classes_num; i++)
    1389                 :           0 :     fprintf (f, " %s", reg_class_names[classes[i]]);
    1390                 :           0 :   fprintf (f, "\nClass translation:\n");
    1391                 :           0 :   for (i = 0; i < N_REG_CLASSES; i++)
    1392                 :           0 :     fprintf (f, " %s -> %s\n", reg_class_names[i],
    1393                 :           0 :              reg_class_names[class_translate[i]]);
    1394                 :           0 : }
    1395                 :             : 
    1396                 :             : /* Output all possible allocno and translation classes and the
    1397                 :             :    translation maps into stderr.  */
    1398                 :             : void
    1399                 :           0 : ira_debug_allocno_classes (void)
    1400                 :             : {
    1401                 :           0 :   print_uniform_and_important_classes (stderr);
    1402                 :           0 :   print_translated_classes (stderr, false);
    1403                 :           0 :   print_translated_classes (stderr, true);
    1404                 :           0 : }
    1405                 :             : 
    1406                 :             : /* Set up different arrays concerning class subsets, allocno and
    1407                 :             :    important classes.  */
    1408                 :             : static void
    1409                 :      206438 : find_reg_classes (void)
    1410                 :             : {
    1411                 :      206438 :   setup_allocno_and_important_classes ();
    1412                 :      206438 :   setup_class_translate ();
    1413                 :      206438 :   reorder_important_classes ();
    1414                 :      206438 :   setup_reg_class_relations ();
    1415                 :      206438 : }
    1416                 :             : 
    1417                 :             : 
    1418                 :             : 
    1419                 :             : /* Set up the array above.  */
    1420                 :             : static void
    1421                 :      206438 : setup_hard_regno_aclass (void)
    1422                 :             : {
    1423                 :      206438 :   int i;
    1424                 :             : 
    1425                 :    19198734 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1426                 :             :     {
    1427                 :             : #if 1
    1428                 :    37984592 :       ira_hard_regno_allocno_class[i]
    1429                 :    28630159 :         = (TEST_HARD_REG_BIT (no_unit_alloc_regs, i)
    1430                 :    18992296 :            ? NO_REGS
    1431                 :     9637863 :            : ira_allocno_class_translate[REGNO_REG_CLASS (i)]);
    1432                 :             : #else
    1433                 :             :       int j;
    1434                 :             :       enum reg_class cl;
    1435                 :             :       ira_hard_regno_allocno_class[i] = NO_REGS;
    1436                 :             :       for (j = 0; j < ira_allocno_classes_num; j++)
    1437                 :             :         {
    1438                 :             :           cl = ira_allocno_classes[j];
    1439                 :             :           if (ira_class_hard_reg_index[cl][i] >= 0)
    1440                 :             :             {
    1441                 :             :               ira_hard_regno_allocno_class[i] = cl;
    1442                 :             :               break;
    1443                 :             :             }
    1444                 :             :         }
    1445                 :             : #endif
    1446                 :             :     }
    1447                 :      206438 : }
    1448                 :             : 
    1449                 :             : 
    1450                 :             : 
    1451                 :             : /* Form IRA_REG_CLASS_MAX_NREGS and IRA_REG_CLASS_MIN_NREGS maps.  */
    1452                 :             : static void
    1453                 :      206438 : setup_reg_class_nregs (void)
    1454                 :             : {
    1455                 :      206438 :   int i, cl, cl2, m;
    1456                 :             : 
    1457                 :    27043378 :   for (m = 0; m < MAX_MACHINE_MODE; m++)
    1458                 :             :     {
    1459                 :   939292900 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
    1460                 :  1824911920 :         ira_reg_class_max_nregs[cl][m]
    1461                 :  1824911920 :           = ira_reg_class_min_nregs[cl][m]
    1462                 :   912455960 :           = targetm.class_max_nregs ((reg_class_t) cl, (machine_mode) m);
    1463                 :   939292900 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
    1464                 :  6537032190 :         for (i = 0;
    1465                 :  7449488150 :              (cl2 = alloc_reg_class_subclasses[cl][i]) != LIM_REG_CLASSES;
    1466                 :             :              i++)
    1467                 :  6537032190 :           if (ira_reg_class_min_nregs[cl2][m]
    1468                 :  6537032190 :               < ira_reg_class_min_nregs[cl][m])
    1469                 :    55006906 :             ira_reg_class_min_nregs[cl][m] = ira_reg_class_min_nregs[cl2][m];
    1470                 :             :     }
    1471                 :      206438 : }
    1472                 :             : 
    1473                 :             : 
    1474                 :             : 
    1475                 :             : /* Set up IRA_PROHIBITED_CLASS_MODE_REGS, IRA_EXCLUDE_CLASS_MODE_REGS, and
    1476                 :             :    IRA_CLASS_SINGLETON.  This function is called once IRA_CLASS_HARD_REGS has
    1477                 :             :    been initialized.  */
    1478                 :             : static void
    1479                 :      206438 : setup_prohibited_and_exclude_class_mode_regs (void)
    1480                 :             : {
    1481                 :      206438 :   int j, k, hard_regno, cl, last_hard_regno, count;
    1482                 :             : 
    1483                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
    1484                 :             :     {
    1485                 :     7018892 :       temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1486                 :   919474852 :       for (j = 0; j < NUM_MACHINE_MODES; j++)
    1487                 :             :         {
    1488                 :   912455960 :           count = 0;
    1489                 :   912455960 :           last_hard_regno = -1;
    1490                 :  3649823840 :           CLEAR_HARD_REG_SET (ira_prohibited_class_mode_regs[cl][j]);
    1491                 :   912455960 :           CLEAR_HARD_REG_SET (ira_exclude_class_mode_regs[cl][j]);
    1492                 : 10155830360 :           for (k = ira_class_hard_regs_num[cl] - 1; k >= 0; k--)
    1493                 :             :             {
    1494                 :  9243374400 :               hard_regno = ira_class_hard_regs[cl][k];
    1495                 :  9243374400 :               if (!targetm.hard_regno_mode_ok (hard_regno, (machine_mode) j))
    1496                 :  7073517278 :                 SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1497                 :             :                                   hard_regno);
    1498                 :  2169857122 :               else if (in_hard_reg_set_p (temp_hard_regset,
    1499                 :             :                                           (machine_mode) j, hard_regno))
    1500                 :             :                 {
    1501                 :  2078036590 :                   last_hard_regno = hard_regno;
    1502                 :  2078036590 :                   count++;
    1503                 :             :                 }
    1504                 :             :               else
    1505                 :             :                 {
    1506                 :    91820532 :                   SET_HARD_REG_BIT (ira_exclude_class_mode_regs[cl][j], hard_regno);
    1507                 :             :                 }
    1508                 :             :             }
    1509                 :   957600081 :           ira_class_singleton[cl][j] = (count == 1 ? last_hard_regno : -1);
    1510                 :             :         }
    1511                 :             :     }
    1512                 :      206438 : }
    1513                 :             : 
    1514                 :             : /* Clarify IRA_PROHIBITED_CLASS_MODE_REGS by excluding hard registers
    1515                 :             :    spanning from one register pressure class to another one.  It is
    1516                 :             :    called after defining the pressure classes.  */
    1517                 :             : static void
    1518                 :      206438 : clarify_prohibited_class_mode_regs (void)
    1519                 :             : {
    1520                 :      206438 :   int j, k, hard_regno, cl, pclass, nregs;
    1521                 :             : 
    1522                 :     7225330 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
    1523                 :   919474852 :     for (j = 0; j < NUM_MACHINE_MODES; j++)
    1524                 :             :       {
    1525                 :   912455960 :         CLEAR_HARD_REG_SET (ira_useful_class_mode_regs[cl][j]);
    1526                 : 10155830360 :         for (k = ira_class_hard_regs_num[cl] - 1; k >= 0; k--)
    1527                 :             :           {
    1528                 :  9243374400 :             hard_regno = ira_class_hard_regs[cl][k];
    1529                 :  9243374400 :             if (TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j], hard_regno))
    1530                 :  7073517278 :               continue;
    1531                 :  2169857122 :             nregs = hard_regno_nregs (hard_regno, (machine_mode) j);
    1532                 :  2169857122 :             if (hard_regno + nregs > FIRST_PSEUDO_REGISTER)
    1533                 :             :               {
    1534                 :        6090 :                 SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1535                 :             :                                   hard_regno);
    1536                 :        6090 :                  continue;
    1537                 :             :               }
    1538                 :  2169851032 :             pclass = ira_pressure_class_translate[REGNO_REG_CLASS (hard_regno)];
    1539                 :  4767454143 :             for (nregs-- ;nregs >= 0; nregs--)
    1540                 :  2645842140 :               if (((enum reg_class) pclass
    1541                 :  2645842140 :                    != ira_pressure_class_translate[REGNO_REG_CLASS
    1542                 :  2645842140 :                                                    (hard_regno + nregs)]))
    1543                 :             :                 {
    1544                 :    48239029 :                   SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1545                 :             :                                     hard_regno);
    1546                 :    48239029 :                   break;
    1547                 :             :                 }
    1548                 :  2169851032 :             if (!TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1549                 :             :                                     hard_regno))
    1550                 :  2121612003 :               add_to_hard_reg_set (&ira_useful_class_mode_regs[cl][j],
    1551                 :             :                                    (machine_mode) j, hard_regno);
    1552                 :             :           }
    1553                 :             :       }
    1554                 :      206438 : }
    1555                 :             : 
    1556                 :             : /* Allocate and initialize IRA_REGISTER_MOVE_COST, IRA_MAY_MOVE_IN_COST
    1557                 :             :    and IRA_MAY_MOVE_OUT_COST for MODE.  */
    1558                 :             : void
    1559                 :     9629259 : ira_init_register_move_cost (machine_mode mode)
    1560                 :             : {
    1561                 :     9629259 :   static unsigned short last_move_cost[N_REG_CLASSES][N_REG_CLASSES];
    1562                 :     9629259 :   bool all_match = true;
    1563                 :     9629259 :   unsigned int i, cl1, cl2;
    1564                 :     9629259 :   HARD_REG_SET ok_regs;
    1565                 :             : 
    1566                 :     9629259 :   ira_assert (ira_register_move_cost[mode] == NULL
    1567                 :             :               && ira_may_move_in_cost[mode] == NULL
    1568                 :             :               && ira_may_move_out_cost[mode] == NULL);
    1569                 :   895521087 :   CLEAR_HARD_REG_SET (ok_regs);
    1570                 :   895521087 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1571                 :   885891828 :     if (targetm.hard_regno_mode_ok (i, mode))
    1572                 :   402813295 :       SET_HARD_REG_BIT (ok_regs, i);
    1573                 :             : 
    1574                 :             :   /* Note that we might be asked about the move costs of modes that
    1575                 :             :      cannot be stored in any hard register, for example if an inline
    1576                 :             :      asm tries to create a register operand with an impossible mode.
    1577                 :             :      We therefore can't assert have_regs_of_mode[mode] here.  */
    1578                 :   337024065 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1579                 : 11458818210 :     for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1580                 :             :       {
    1581                 : 11131423404 :         int cost;
    1582                 : 11131423404 :         if (!hard_reg_set_intersect_p (ok_regs, reg_class_contents[cl1])
    1583                 : 18401614606 :             || !hard_reg_set_intersect_p (ok_regs, reg_class_contents[cl2]))
    1584                 :             :           {
    1585                 :  5814569489 :             if ((ira_reg_class_max_nregs[cl1][mode]
    1586                 :  5814569489 :                  > ira_class_hard_regs_num[cl1])
    1587                 :  4125901927 :                 || (ira_reg_class_max_nregs[cl2][mode]
    1588                 :  4125901927 :                     > ira_class_hard_regs_num[cl2]))
    1589                 :             :               cost = 65535;
    1590                 :             :             else
    1591                 :  2838500768 :               cost = (ira_memory_move_cost[mode][cl1][0]
    1592                 :  2838500768 :                       + ira_memory_move_cost[mode][cl2][1]) * 2;
    1593                 :             :           }
    1594                 :             :         else
    1595                 :             :           {
    1596                 :  5316853915 :             cost = register_move_cost (mode, (enum reg_class) cl1,
    1597                 :             :                                        (enum reg_class) cl2);
    1598                 :  5316853915 :             ira_assert (cost < 65535);
    1599                 :             :           }
    1600                 : 11131423404 :         all_match &= (last_move_cost[cl1][cl2] == cost);
    1601                 : 11131423404 :         last_move_cost[cl1][cl2] = cost;
    1602                 :             :       }
    1603                 :     9629259 :   if (all_match && last_mode_for_init_move_cost != -1)
    1604                 :             :     {
    1605                 :     3997655 :       ira_register_move_cost[mode]
    1606                 :     3997655 :         = ira_register_move_cost[last_mode_for_init_move_cost];
    1607                 :     3997655 :       ira_may_move_in_cost[mode]
    1608                 :     3997655 :         = ira_may_move_in_cost[last_mode_for_init_move_cost];
    1609                 :     3997655 :       ira_may_move_out_cost[mode]
    1610                 :     3997655 :         = ira_may_move_out_cost[last_mode_for_init_move_cost];
    1611                 :     3997655 :       return;
    1612                 :             :     }
    1613                 :     5631604 :   last_mode_for_init_move_cost = mode;
    1614                 :     5631604 :   ira_register_move_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1615                 :     5631604 :   ira_may_move_in_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1616                 :     5631604 :   ira_may_move_out_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1617                 :   197106140 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1618                 :  6701608760 :     for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1619                 :             :       {
    1620                 :  6510134224 :         int cost;
    1621                 :  6510134224 :         enum reg_class *p1, *p2;
    1622                 :             :         
    1623                 :  6510134224 :         if (last_move_cost[cl1][cl2] == 65535)
    1624                 :             :           {
    1625                 :  1625753830 :             ira_register_move_cost[mode][cl1][cl2] = 65535;
    1626                 :  1625753830 :             ira_may_move_in_cost[mode][cl1][cl2] = 65535;
    1627                 :  1625753830 :             ira_may_move_out_cost[mode][cl1][cl2] = 65535;
    1628                 :             :           }
    1629                 :             :         else
    1630                 :             :           {
    1631                 :  4884380394 :             cost = last_move_cost[cl1][cl2];
    1632                 :             :             
    1633                 : 40927924427 :             for (p2 = &reg_class_subclasses[cl2][0];
    1634                 : 40927924427 :                  *p2 != LIM_REG_CLASSES; p2++)
    1635                 : 36043544033 :               if (ira_class_hard_regs_num[*p2] > 0
    1636                 : 35379254899 :                   && (ira_reg_class_max_nregs[*p2][mode]
    1637                 :             :                       <= ira_class_hard_regs_num[*p2]))
    1638                 : 29014849841 :                 cost = MAX (cost, ira_register_move_cost[mode][cl1][*p2]);
    1639                 :             :             
    1640                 : 40927924427 :             for (p1 = &reg_class_subclasses[cl1][0];
    1641                 : 40927924427 :                  *p1 != LIM_REG_CLASSES; p1++)
    1642                 : 36043544033 :               if (ira_class_hard_regs_num[*p1] > 0
    1643                 : 35379254899 :                   && (ira_reg_class_max_nregs[*p1][mode]
    1644                 :             :                       <= ira_class_hard_regs_num[*p1]))
    1645                 : 29014849841 :                 cost = MAX (cost, ira_register_move_cost[mode][*p1][cl2]);
    1646                 :             :             
    1647                 :  4884380394 :             ira_assert (cost <= 65535);
    1648                 :  4884380394 :             ira_register_move_cost[mode][cl1][cl2] = cost;
    1649                 :             :             
    1650                 :  4884380394 :             if (ira_class_subset_p[cl1][cl2])
    1651                 :  1474562608 :               ira_may_move_in_cost[mode][cl1][cl2] = 0;
    1652                 :             :             else
    1653                 :  3409817786 :               ira_may_move_in_cost[mode][cl1][cl2] = cost;
    1654                 :             :             
    1655                 :  4884380394 :             if (ira_class_subset_p[cl2][cl1])
    1656                 :  1474562608 :               ira_may_move_out_cost[mode][cl1][cl2] = 0;
    1657                 :             :             else
    1658                 :  3409817786 :               ira_may_move_out_cost[mode][cl1][cl2] = cost;
    1659                 :             :           }
    1660                 :             :       }
    1661                 :             : }
    1662                 :             : 
    1663                 :             : 
    1664                 :             : 
    1665                 :             : /* This is called once during compiler work.  It sets up
    1666                 :             :    different arrays whose values don't depend on the compiled
    1667                 :             :    function.  */
    1668                 :             : void
    1669                 :      201113 : ira_init_once (void)
    1670                 :             : {
    1671                 :      201113 :   ira_init_costs_once ();
    1672                 :      201113 :   lra_init_once ();
    1673                 :             : 
    1674                 :      201113 :   ira_use_lra_p = targetm.lra_p ();
    1675                 :      201113 : }
    1676                 :             : 
    1677                 :             : /* Free ira_max_register_move_cost, ira_may_move_in_cost and
    1678                 :             :    ira_may_move_out_cost for each mode.  */
    1679                 :             : void
    1680                 :      503206 : target_ira_int::free_register_move_costs (void)
    1681                 :             : {
    1682                 :      503206 :   int mode, i;
    1683                 :             : 
    1684                 :             :   /* Reset move_cost and friends, making sure we only free shared
    1685                 :             :      table entries once.  */
    1686                 :    65919986 :   for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
    1687                 :    65416780 :     if (x_ira_register_move_cost[mode])
    1688                 :             :       {
    1689                 :   579171486 :         for (i = 0;
    1690                 :   588043446 :              i < mode && (x_ira_register_move_cost[i]
    1691                 :             :                           != x_ira_register_move_cost[mode]);
    1692                 :             :              i++)
    1693                 :             :           ;
    1694                 :     8871960 :         if (i == mode)
    1695                 :             :           {
    1696                 :     5191972 :             free (x_ira_register_move_cost[mode]);
    1697                 :     5191972 :             free (x_ira_may_move_in_cost[mode]);
    1698                 :     5191972 :             free (x_ira_may_move_out_cost[mode]);
    1699                 :             :           }
    1700                 :             :       }
    1701                 :      503206 :   memset (x_ira_register_move_cost, 0, sizeof x_ira_register_move_cost);
    1702                 :      503206 :   memset (x_ira_may_move_in_cost, 0, sizeof x_ira_may_move_in_cost);
    1703                 :      503206 :   memset (x_ira_may_move_out_cost, 0, sizeof x_ira_may_move_out_cost);
    1704                 :      503206 :   last_mode_for_init_move_cost = -1;
    1705                 :      503206 : }
    1706                 :             : 
    1707                 :      296768 : target_ira_int::~target_ira_int ()
    1708                 :             : {
    1709                 :      296768 :   free_ira_costs ();
    1710                 :      296768 :   free_register_move_costs ();
    1711                 :      296768 : }
    1712                 :             : 
    1713                 :             : /* This is called every time when register related information is
    1714                 :             :    changed.  */
    1715                 :             : void
    1716                 :      206438 : ira_init (void)
    1717                 :             : {
    1718                 :      206438 :   this_target_ira_int->free_register_move_costs ();
    1719                 :      206438 :   setup_reg_mode_hard_regset ();
    1720                 :      206438 :   setup_alloc_regs (flag_omit_frame_pointer != 0);
    1721                 :      206438 :   setup_class_subset_and_memory_move_costs ();
    1722                 :      206438 :   setup_reg_class_nregs ();
    1723                 :      206438 :   setup_prohibited_and_exclude_class_mode_regs ();
    1724                 :      206438 :   find_reg_classes ();
    1725                 :      206438 :   clarify_prohibited_class_mode_regs ();
    1726                 :      206438 :   setup_hard_regno_aclass ();
    1727                 :      206438 :   ira_init_costs ();
    1728                 :      206438 : }
    1729                 :             : 
    1730                 :             : 
    1731                 :             : #define ira_prohibited_mode_move_regs_initialized_p \
    1732                 :             :   (this_target_ira_int->x_ira_prohibited_mode_move_regs_initialized_p)
    1733                 :             : 
    1734                 :             : /* Set up IRA_PROHIBITED_MODE_MOVE_REGS.  */
    1735                 :             : static void
    1736                 :     1421530 : setup_prohibited_mode_move_regs (void)
    1737                 :             : {
    1738                 :     1421530 :   int i, j;
    1739                 :     1421530 :   rtx test_reg1, test_reg2, move_pat;
    1740                 :     1421530 :   rtx_insn *move_insn;
    1741                 :             : 
    1742                 :     1421530 :   if (ira_prohibited_mode_move_regs_initialized_p)
    1743                 :             :     return;
    1744                 :      204202 :   ira_prohibited_mode_move_regs_initialized_p = true;
    1745                 :      204202 :   test_reg1 = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
    1746                 :      204202 :   test_reg2 = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 2);
    1747                 :      204202 :   move_pat = gen_rtx_SET (test_reg1, test_reg2);
    1748                 :      204202 :   move_insn = gen_rtx_INSN (VOIDmode, 0, 0, 0, move_pat, 0, -1, 0);
    1749                 :    26954664 :   for (i = 0; i < NUM_MACHINE_MODES; i++)
    1750                 :             :     {
    1751                 :    26546260 :       SET_HARD_REG_SET (ira_prohibited_mode_move_regs[i]);
    1752                 :  2468802180 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
    1753                 :             :         {
    1754                 :  2442255920 :           if (!targetm.hard_regno_mode_ok (j, (machine_mode) i))
    1755                 :  2039628894 :             continue;
    1756                 :   402627026 :           set_mode_and_regno (test_reg1, (machine_mode) i, j);
    1757                 :   402627026 :           set_mode_and_regno (test_reg2, (machine_mode) i, j);
    1758                 :   402627026 :           INSN_CODE (move_insn) = -1;
    1759                 :   402627026 :           recog_memoized (move_insn);
    1760                 :   402627026 :           if (INSN_CODE (move_insn) < 0)
    1761                 :   190526680 :             continue;
    1762                 :   212100346 :           extract_insn (move_insn);
    1763                 :             :           /* We don't know whether the move will be in code that is optimized
    1764                 :             :              for size or speed, so consider all enabled alternatives.  */
    1765                 :   212100346 :           if (! constrain_operands (1, get_enabled_alternatives (move_insn)))
    1766                 :     1252613 :             continue;
    1767                 :   210847733 :           CLEAR_HARD_REG_BIT (ira_prohibited_mode_move_regs[i], j);
    1768                 :             :         }
    1769                 :             :     }
    1770                 :             : }
    1771                 :             : 
    1772                 :             : 
    1773                 :             : 
    1774                 :             : /* Extract INSN and return the set of alternatives that we should consider.
    1775                 :             :    This excludes any alternatives whose constraints are obviously impossible
    1776                 :             :    to meet (e.g. because the constraint requires a constant and the operand
    1777                 :             :    is nonconstant).  It also excludes alternatives that are bound to need
    1778                 :             :    a spill or reload, as long as we have other alternatives that match
    1779                 :             :    exactly.  */
    1780                 :             : alternative_mask
    1781                 :    96467607 : ira_setup_alts (rtx_insn *insn)
    1782                 :             : {
    1783                 :    96467607 :   int nop, nalt;
    1784                 :    96467607 :   bool curr_swapped;
    1785                 :    96467607 :   const char *p;
    1786                 :    96467607 :   int commutative = -1;
    1787                 :             : 
    1788                 :    96467607 :   extract_insn (insn);
    1789                 :    96467607 :   preprocess_constraints (insn);
    1790                 :    96467607 :   alternative_mask preferred = get_preferred_alternatives (insn);
    1791                 :    96467607 :   alternative_mask alts = 0;
    1792                 :    96467607 :   alternative_mask exact_alts = 0;
    1793                 :             :   /* Check that the hard reg set is enough for holding all
    1794                 :             :      alternatives.  It is hard to imagine the situation when the
    1795                 :             :      assertion is wrong.  */
    1796                 :    96467607 :   ira_assert (recog_data.n_alternatives
    1797                 :             :               <= (int) MAX (sizeof (HARD_REG_ELT_TYPE) * CHAR_BIT,
    1798                 :             :                             FIRST_PSEUDO_REGISTER));
    1799                 :   283181126 :   for (nop = 0; nop < recog_data.n_operands; nop++)
    1800                 :   198030878 :     if (recog_data.constraints[nop][0] == '%')
    1801                 :             :       {
    1802                 :             :         commutative = nop;
    1803                 :             :         break;
    1804                 :             :       }
    1805                 :    96467607 :   for (curr_swapped = false;; curr_swapped = true)
    1806                 :             :     {
    1807                 :  1281581942 :       for (nalt = 0; nalt < recog_data.n_alternatives; nalt++)
    1808                 :             :         {
    1809                 :  1173796976 :           if (!TEST_BIT (preferred, nalt) || TEST_BIT (exact_alts, nalt))
    1810                 :   238789863 :             continue;
    1811                 :             : 
    1812                 :   935007113 :           const operand_alternative *op_alt
    1813                 :   935007113 :             = &recog_op_alt[nalt * recog_data.n_operands];
    1814                 :   935007113 :           int this_reject = 0;
    1815                 :  2441787156 :           for (nop = 0; nop < recog_data.n_operands; nop++)
    1816                 :             :             {
    1817                 :  1838227519 :               int c, len;
    1818                 :             : 
    1819                 :  1838227519 :               this_reject += op_alt[nop].reject;
    1820                 :             : 
    1821                 :  1838227519 :               rtx op = recog_data.operand[nop];
    1822                 :  1838227519 :               p = op_alt[nop].constraint;
    1823                 :  1838227519 :               if (*p == 0 || *p == ',')
    1824                 :    23060923 :                 continue;
    1825                 :             : 
    1826                 :             :               bool win_p = false;
    1827                 :  3854857684 :               do
    1828                 :  3854857684 :                 switch (c = *p, len = CONSTRAINT_LEN (c, p), c)
    1829                 :             :                   {
    1830                 :             :                   case '#':
    1831                 :             :                   case ',':
    1832                 :             :                     c = '\0';
    1833                 :             :                     /* FALLTHRU */
    1834                 :   858051095 :                   case '\0':
    1835                 :   858051095 :                     len = 0;
    1836                 :   858051095 :                     break;
    1837                 :             :                   
    1838                 :             :                   case '%':
    1839                 :             :                     /* The commutative modifier is handled above.  */
    1840                 :             :                     break;
    1841                 :             : 
    1842                 :    69728224 :                   case '0':  case '1':  case '2':  case '3':  case '4':
    1843                 :    69728224 :                   case '5':  case '6':  case '7':  case '8':  case '9':
    1844                 :    69728224 :                     {
    1845                 :    69728224 :                       char *end;
    1846                 :    69728224 :                       unsigned long dup = strtoul (p, &end, 10);
    1847                 :    69728224 :                       rtx other = recog_data.operand[dup];
    1848                 :    69728224 :                       len = end - p;
    1849                 :     1694205 :                       if (MEM_P (other)
    1850                 :    69728224 :                           ? rtx_equal_p (other, op)
    1851                 :    68034019 :                           : REG_P (op) || SUBREG_P (op))
    1852                 :    48236065 :                         goto op_success;
    1853                 :    21492159 :                       win_p = true;
    1854                 :             :                     }
    1855                 :    21492159 :                     break;
    1856                 :             :                     
    1857                 :    10154509 :                   case 'g':
    1858                 :    10154509 :                     goto op_success;
    1859                 :  2899025995 :                     break;
    1860                 :             :                     
    1861                 :  2899025995 :                   default:
    1862                 :  2899025995 :                     {
    1863                 :  2899025995 :                       enum constraint_num cn = lookup_constraint (p);
    1864                 :  2899025995 :                       rtx mem = NULL;
    1865                 :  2899025995 :                       switch (get_constraint_type (cn))
    1866                 :             :                         {
    1867                 :  2415455622 :                         case CT_REGISTER:
    1868                 :  3762530237 :                           if (reg_class_for_constraint (cn) != NO_REGS)
    1869                 :             :                             {
    1870                 :  1149214893 :                               if (REG_P (op) || SUBREG_P (op))
    1871                 :   756690074 :                                 goto op_success;
    1872                 :             :                               win_p = true;
    1873                 :             :                             }
    1874                 :             :                           break;
    1875                 :             : 
    1876                 :     3766587 :                         case CT_CONST_INT:
    1877                 :     3766587 :                           if (CONST_INT_P (op)
    1878                 :     6203223 :                               && (insn_const_int_ok_for_constraint
    1879                 :     2436636 :                                   (INTVAL (op), cn)))
    1880                 :     1689401 :                             goto op_success;
    1881                 :             :                           break;
    1882                 :             : 
    1883                 :      709239 :                         case CT_ADDRESS:
    1884                 :      709239 :                           goto op_success;
    1885                 :             : 
    1886                 :   179812870 :                         case CT_MEMORY:
    1887                 :   179812870 :                         case CT_RELAXED_MEMORY:
    1888                 :   179812870 :                           mem = op;
    1889                 :             :                           /* Fall through.  */
    1890                 :   179812870 :                         case CT_SPECIAL_MEMORY:
    1891                 :   179812870 :                           if (!mem)
    1892                 :    62672983 :                             mem = extract_mem_from_operand (op);
    1893                 :   242485853 :                           if (MEM_P (mem))
    1894                 :    73316755 :                             goto op_success;
    1895                 :             :                           win_p = true;
    1896                 :             :                           break;
    1897                 :             : 
    1898                 :   236608694 :                         case CT_FIXED_FORM:
    1899                 :   236608694 :                           if (constraint_satisfied_p (op, cn))
    1900                 :    66319458 :                             goto op_success;
    1901                 :             :                           break;
    1902                 :             :                         }
    1903                 :             :                       break;
    1904                 :             :                     }
    1905                 :             :                   }
    1906                 :  2897742183 :               while (p += len, c);
    1907                 :   858051095 :               if (!win_p)
    1908                 :             :                 break;
    1909                 :             :               /* We can make the alternative match by spilling a register
    1910                 :             :                  to memory or loading something into a register.  Count a
    1911                 :             :                  cost of one reload (the equivalent of the '?' constraint).  */
    1912                 :   526603619 :               this_reject += 6;
    1913                 :  1506780043 :             op_success:
    1914                 :  1506780043 :               ;
    1915                 :             :             }
    1916                 :             : 
    1917                 :   935007113 :           if (nop >= recog_data.n_operands)
    1918                 :             :             {
    1919                 :   603559637 :               alts |= ALTERNATIVE_BIT (nalt);
    1920                 :   603559637 :               if (this_reject == 0)
    1921                 :   128067924 :                 exact_alts |= ALTERNATIVE_BIT (nalt);
    1922                 :             :             }
    1923                 :             :         }
    1924                 :   107784966 :       if (commutative < 0)
    1925                 :             :         break;
    1926                 :             :       /* Swap forth and back to avoid changing recog_data.  */
    1927                 :    22634718 :       std::swap (recog_data.operand[commutative],
    1928                 :    22634718 :                  recog_data.operand[commutative + 1]);
    1929                 :    22634718 :       if (curr_swapped)
    1930                 :             :         break;
    1931                 :             :     }
    1932                 :    96467607 :   return exact_alts ? exact_alts : alts;
    1933                 :             : }
    1934                 :             : 
    1935                 :             : /* Return the number of the output non-early clobber operand which
    1936                 :             :    should be the same in any case as operand with number OP_NUM (or
    1937                 :             :    negative value if there is no such operand).  ALTS is the mask
    1938                 :             :    of alternatives that we should consider.  SINGLE_INPUT_OP_HAS_CSTR_P
    1939                 :             :    should be set in this function, it indicates whether there is only
    1940                 :             :    a single input operand which has the matching constraint on the
    1941                 :             :    output operand at the position specified in return value.  If the
    1942                 :             :    pattern allows any one of several input operands holds the matching
    1943                 :             :    constraint, it's set as false, one typical case is destructive FMA
    1944                 :             :    instruction on target rs6000.  Note that for a non-NO_REG preferred
    1945                 :             :    register class with no free register move copy, if the parameter
    1946                 :             :    PARAM_IRA_CONSIDER_DUP_IN_ALL_ALTS is set to one, this function
    1947                 :             :    will check all available alternatives for matching constraints,
    1948                 :             :    even if it has found or will find one alternative with non-NO_REG
    1949                 :             :    regclass, it can respect more cases with matching constraints.  If
    1950                 :             :    PARAM_IRA_CONSIDER_DUP_IN_ALL_ALTS is set to zero,
    1951                 :             :    SINGLE_INPUT_OP_HAS_CSTR_P is always true, it will stop to find
    1952                 :             :    matching constraint relationship once it hits some alternative with
    1953                 :             :    some non-NO_REG regclass.  */
    1954                 :             : int
    1955                 :    19002946 : ira_get_dup_out_num (int op_num, alternative_mask alts,
    1956                 :             :                      bool &single_input_op_has_cstr_p)
    1957                 :             : {
    1958                 :    19002946 :   int curr_alt, c, original;
    1959                 :    19002946 :   bool ignore_p, use_commut_op_p;
    1960                 :    19002946 :   const char *str;
    1961                 :             : 
    1962                 :    19002946 :   if (op_num < 0 || recog_data.n_alternatives == 0)
    1963                 :             :     return -1;
    1964                 :             :   /* We should find duplications only for input operands.  */
    1965                 :    19002946 :   if (recog_data.operand_type[op_num] != OP_IN)
    1966                 :             :     return -1;
    1967                 :    13713219 :   str = recog_data.constraints[op_num];
    1968                 :    13713219 :   use_commut_op_p = false;
    1969                 :    13713219 :   single_input_op_has_cstr_p = true;
    1970                 :             : 
    1971                 :    13713219 :   rtx op = recog_data.operand[op_num];
    1972                 :    13713219 :   int op_regno = reg_or_subregno (op);
    1973                 :    13713219 :   enum reg_class op_pref_cl = reg_preferred_class (op_regno);
    1974                 :    13713219 :   machine_mode op_mode = GET_MODE (op);
    1975                 :             : 
    1976                 :    13713219 :   ira_init_register_move_cost_if_necessary (op_mode);
    1977                 :             :   /* If the preferred regclass isn't NO_REG, continue to find the matching
    1978                 :             :      constraint in all available alternatives with preferred regclass, even
    1979                 :             :      if we have found or will find one alternative whose constraint stands
    1980                 :             :      for a REG (non-NO_REG) regclass.  Note that it would be fine not to
    1981                 :             :      respect matching constraint if the register copy is free, so exclude
    1982                 :             :      it.  */
    1983                 :    13713219 :   bool respect_dup_despite_reg_cstr
    1984                 :    13713219 :     = param_ira_consider_dup_in_all_alts
    1985                 :         467 :       && op_pref_cl != NO_REGS
    1986                 :    13713682 :       && ira_register_move_cost[op_mode][op_pref_cl][op_pref_cl] > 0;
    1987                 :             : 
    1988                 :             :   /* Record the alternative whose constraint uses the same regclass as the
    1989                 :             :      preferred regclass, later if we find one matching constraint for this
    1990                 :             :      operand with preferred reclass, we will visit these recorded
    1991                 :             :      alternatives to check whether if there is one alternative in which no
    1992                 :             :      any INPUT operands have one matching constraint same as our candidate.
    1993                 :             :      If yes, it means there is one alternative which is perfectly fine
    1994                 :             :      without satisfying this matching constraint.  If no, it means in any
    1995                 :             :      alternatives there is one other INPUT operand holding this matching
    1996                 :             :      constraint, it's fine to respect this matching constraint and further
    1997                 :             :      create this constraint copy since it would become harmless once some
    1998                 :             :      other takes preference and it's interfered.  */
    1999                 :    15927953 :   alternative_mask pref_cl_alts;
    2000                 :             : 
    2001                 :    15927953 :   for (;;)
    2002                 :             :     {
    2003                 :    15927953 :       pref_cl_alts = 0;
    2004                 :             : 
    2005                 :    15927953 :       for (curr_alt = 0, ignore_p = !TEST_BIT (alts, curr_alt),
    2006                 :    15927953 :            original = -1;;)
    2007                 :             :         {
    2008                 :    92567257 :           c = *str;
    2009                 :    92567257 :           if (c == '\0')
    2010                 :             :             break;
    2011                 :    88021334 :           if (c == '#')
    2012                 :             :             ignore_p = true;
    2013                 :    88021334 :           else if (c == ',')
    2014                 :             :             {
    2015                 :    28516470 :               curr_alt++;
    2016                 :    28516470 :               ignore_p = !TEST_BIT (alts, curr_alt);
    2017                 :             :             }
    2018                 :    59504864 :           else if (! ignore_p)
    2019                 :    19036158 :             switch (c)
    2020                 :             :               {
    2021                 :         934 :               case 'g':
    2022                 :         934 :                 goto fail;
    2023                 :    14301220 :               default:
    2024                 :    14301220 :                 {
    2025                 :    14301220 :                   enum constraint_num cn = lookup_constraint (str);
    2026                 :    14301220 :                   enum reg_class cl = reg_class_for_constraint (cn);
    2027                 :    11656264 :                   if (cl != NO_REGS && !targetm.class_likely_spilled_p (cl))
    2028                 :             :                     {
    2029                 :    11379824 :                       if (respect_dup_despite_reg_cstr)
    2030                 :             :                         {
    2031                 :             :                           /* If it's free to move from one preferred class to
    2032                 :             :                              the one without matching constraint, it doesn't
    2033                 :             :                              have to respect this constraint with costs.  */
    2034                 :         636 :                           if (cl != op_pref_cl
    2035                 :          91 :                               && (ira_reg_class_intersect[cl][op_pref_cl]
    2036                 :             :                                   != NO_REGS)
    2037                 :          86 :                               && (ira_may_move_in_cost[op_mode][op_pref_cl][cl]
    2038                 :             :                                   == 0))
    2039                 :          70 :                             goto fail;
    2040                 :         566 :                           else if (cl == op_pref_cl)
    2041                 :         545 :                             pref_cl_alts |= ALTERNATIVE_BIT (curr_alt);
    2042                 :             :                         }
    2043                 :             :                       else
    2044                 :    11379188 :                         goto fail;
    2045                 :             :                     }
    2046                 :     2921962 :                   if (constraint_satisfied_p (op, cn))
    2047                 :        1838 :                     goto fail;
    2048                 :             :                   break;
    2049                 :             :                 }
    2050                 :             :                 
    2051                 :     4734004 :               case '0': case '1': case '2': case '3': case '4':
    2052                 :     4734004 :               case '5': case '6': case '7': case '8': case '9':
    2053                 :     4734004 :                 {
    2054                 :     4734004 :                   char *end;
    2055                 :     4734004 :                   int n = (int) strtoul (str, &end, 10);
    2056                 :     4734004 :                   str = end;
    2057                 :     4734004 :                   if (original != -1 && original != n)
    2058                 :           0 :                     goto fail;
    2059                 :     4734004 :                   gcc_assert (n < recog_data.n_operands);
    2060                 :     4734004 :                   if (respect_dup_despite_reg_cstr)
    2061                 :             :                     {
    2062                 :         231 :                       const operand_alternative *op_alt
    2063                 :         231 :                         = &recog_op_alt[curr_alt * recog_data.n_operands];
    2064                 :             :                       /* Only respect the one with preferred rclass, without
    2065                 :             :                          respect_dup_despite_reg_cstr it's possible to get
    2066                 :             :                          one whose regclass isn't preferred first before,
    2067                 :             :                          but it would fail since there should be other
    2068                 :             :                          alternatives with preferred regclass.  */
    2069                 :         231 :                       if (op_alt[n].cl == op_pref_cl)
    2070                 :     4733935 :                         original = n;
    2071                 :             :                     }
    2072                 :             :                   else
    2073                 :             :                     original = n;
    2074                 :     4734004 :                   continue;
    2075                 :     4734004 :                 }
    2076                 :             :               }
    2077                 :    71905300 :           str += CONSTRAINT_LEN (c, str);
    2078                 :             :         }
    2079                 :     4545923 :       if (original == -1)
    2080                 :     1728668 :         goto fail;
    2081                 :     2817255 :       if (recog_data.operand_type[original] == OP_OUT)
    2082                 :             :         {
    2083                 :     2816801 :           if (pref_cl_alts == 0)
    2084                 :             :             return original;
    2085                 :             :           /* Visit these recorded alternatives to check whether
    2086                 :             :              there is one alternative in which no any INPUT operands
    2087                 :             :              have one matching constraint same as our candidate.
    2088                 :             :              Give up this candidate if so.  */
    2089                 :             :           int nop, nalt;
    2090                 :         371 :           for (nalt = 0; nalt < recog_data.n_alternatives; nalt++)
    2091                 :             :             {
    2092                 :         346 :               if (!TEST_BIT (pref_cl_alts, nalt))
    2093                 :         246 :                 continue;
    2094                 :         100 :               const operand_alternative *op_alt
    2095                 :         100 :                 = &recog_op_alt[nalt * recog_data.n_operands];
    2096                 :         100 :               bool dup_in_other = false;
    2097                 :         369 :               for (nop = 0; nop < recog_data.n_operands; nop++)
    2098                 :             :                 {
    2099                 :         313 :                   if (recog_data.operand_type[nop] != OP_IN)
    2100                 :         100 :                     continue;
    2101                 :         213 :                   if (nop == op_num)
    2102                 :          88 :                     continue;
    2103                 :         125 :                   if (op_alt[nop].matches == original)
    2104                 :             :                     {
    2105                 :             :                       dup_in_other = true;
    2106                 :             :                       break;
    2107                 :             :                     }
    2108                 :             :                 }
    2109                 :         100 :               if (!dup_in_other)
    2110                 :             :                 return -1;
    2111                 :             :             }
    2112                 :          25 :           single_input_op_has_cstr_p = false;
    2113                 :          25 :           return original;
    2114                 :             :         }
    2115                 :         454 :     fail:
    2116                 :    13111152 :       if (use_commut_op_p)
    2117                 :             :         break;
    2118                 :    11617142 :       use_commut_op_p = true;
    2119                 :    11617142 :       if (recog_data.constraints[op_num][0] == '%')
    2120                 :      971771 :         str = recog_data.constraints[op_num + 1];
    2121                 :    10645371 :       else if (op_num > 0 && recog_data.constraints[op_num - 1][0] == '%')
    2122                 :             :         str = recog_data.constraints[op_num - 1];
    2123                 :             :       else
    2124                 :             :         break;
    2125                 :             :     }
    2126                 :             :   return -1;
    2127                 :             : }
    2128                 :             : 
    2129                 :             : 
    2130                 :             : 
    2131                 :             : /* Search forward to see if the source register of a copy insn dies
    2132                 :             :    before either it or the destination register is modified, but don't
    2133                 :             :    scan past the end of the basic block.  If so, we can replace the
    2134                 :             :    source with the destination and let the source die in the copy
    2135                 :             :    insn.
    2136                 :             : 
    2137                 :             :    This will reduce the number of registers live in that range and may
    2138                 :             :    enable the destination and the source coalescing, thus often saving
    2139                 :             :    one register in addition to a register-register copy.  */
    2140                 :             : 
    2141                 :             : static void
    2142                 :     1421530 : decrease_live_ranges_number (void)
    2143                 :             : {
    2144                 :     1421530 :   basic_block bb;
    2145                 :     1421530 :   rtx_insn *insn;
    2146                 :     1421530 :   rtx set, src, dest, dest_death, note;
    2147                 :     1421530 :   rtx_insn *p, *q;
    2148                 :     1421530 :   int sregno, dregno;
    2149                 :             : 
    2150                 :     1421530 :   if (! flag_expensive_optimizations)
    2151                 :             :     return;
    2152                 :             : 
    2153                 :      922993 :   if (ira_dump_file)
    2154                 :          32 :     fprintf (ira_dump_file, "Starting decreasing number of live ranges...\n");
    2155                 :             : 
    2156                 :    10441779 :   FOR_EACH_BB_FN (bb, cfun)
    2157                 :   118013522 :     FOR_BB_INSNS (bb, insn)
    2158                 :             :       {
    2159                 :   108494736 :         set = single_set (insn);
    2160                 :   108494736 :         if (! set)
    2161                 :    60874877 :           continue;
    2162                 :    47619859 :         src = SET_SRC (set);
    2163                 :    47619859 :         dest = SET_DEST (set);
    2164                 :    13009224 :         if (! REG_P (src) || ! REG_P (dest)
    2165                 :    55893699 :             || find_reg_note (insn, REG_DEAD, src))
    2166                 :    45049887 :           continue;
    2167                 :     2569972 :         sregno = REGNO (src);
    2168                 :     2569972 :         dregno = REGNO (dest);
    2169                 :             :         
    2170                 :             :         /* We don't want to mess with hard regs if register classes
    2171                 :             :            are small.  */
    2172                 :     4752503 :         if (sregno == dregno
    2173                 :     2569972 :             || (targetm.small_register_classes_for_mode_p (GET_MODE (src))
    2174                 :     2569972 :                 && (sregno < FIRST_PSEUDO_REGISTER
    2175                 :     2569972 :                     || dregno < FIRST_PSEUDO_REGISTER))
    2176                 :             :             /* We don't see all updates to SP if they are in an
    2177                 :             :                auto-inc memory reference, so we must disallow this
    2178                 :             :                optimization on them.  */
    2179                 :      387441 :             || sregno == STACK_POINTER_REGNUM
    2180                 :     2957413 :             || dregno == STACK_POINTER_REGNUM)
    2181                 :     2182531 :           continue;
    2182                 :             :         
    2183                 :      387441 :         dest_death = NULL_RTX;
    2184                 :             : 
    2185                 :     4807150 :         for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
    2186                 :             :           {
    2187                 :     4804066 :             if (! INSN_P (p))
    2188                 :      803181 :               continue;
    2189                 :     4000885 :             if (BLOCK_FOR_INSN (p) != bb)
    2190                 :             :               break;
    2191                 :             :             
    2192                 :     7316439 :             if (reg_set_p (src, p) || reg_set_p (dest, p)
    2193                 :             :                 /* If SRC is an asm-declared register, it must not be
    2194                 :             :                    replaced in any asm.  Unfortunately, the REG_EXPR
    2195                 :             :                    tree for the asm variable may be absent in the SRC
    2196                 :             :                    rtx, so we can't check the actual register
    2197                 :             :                    declaration easily (the asm operand will have it,
    2198                 :             :                    though).  To avoid complicating the test for a rare
    2199                 :             :                    case, we just don't perform register replacement
    2200                 :             :                    for a hard reg mentioned in an asm.  */
    2201                 :     3620899 :                 || (sregno < FIRST_PSEUDO_REGISTER
    2202                 :           0 :                     && asm_noperands (PATTERN (p)) >= 0
    2203                 :           0 :                     && reg_overlap_mentioned_p (src, PATTERN (p)))
    2204                 :             :                 /* Don't change hard registers used by a call.  */
    2205                 :     3620899 :                 || (CALL_P (p) && sregno < FIRST_PSEUDO_REGISTER
    2206                 :           0 :                     && find_reg_fusage (p, USE, src))
    2207                 :             :                 /* Don't change a USE of a register.  */
    2208                 :     7292079 :                 || (GET_CODE (PATTERN (p)) == USE
    2209                 :         787 :                     && reg_overlap_mentioned_p (src, XEXP (PATTERN (p), 0))))
    2210                 :             :               break;
    2211                 :             :             
    2212                 :             :             /* See if all of SRC dies in P.  This test is slightly
    2213                 :             :                more conservative than it needs to be.  */
    2214                 :     3620899 :             if ((note = find_regno_note (p, REG_DEAD, sregno))
    2215                 :     3620899 :                 && GET_MODE (XEXP (note, 0)) == GET_MODE (src))
    2216                 :             :               {
    2217                 :        4371 :                 int failed = 0;
    2218                 :             :                 
    2219                 :             :                 /* We can do the optimization.  Scan forward from INSN
    2220                 :             :                    again, replacing regs as we go.  Set FAILED if a
    2221                 :             :                    replacement can't be done.  In that case, we can't
    2222                 :             :                    move the death note for SRC.  This should be
    2223                 :             :                    rare.  */
    2224                 :             :                 
    2225                 :             :                 /* Set to stop at next insn.  */
    2226                 :        4371 :                 for (q = next_real_insn (insn);
    2227                 :       25847 :                      q != next_real_insn (p);
    2228                 :       21476 :                      q = next_real_insn (q))
    2229                 :             :                   {
    2230                 :       21476 :                     if (reg_overlap_mentioned_p (src, PATTERN (q)))
    2231                 :             :                       {
    2232                 :             :                         /* If SRC is a hard register, we might miss
    2233                 :             :                            some overlapping registers with
    2234                 :             :                            validate_replace_rtx, so we would have to
    2235                 :             :                            undo it.  We can't if DEST is present in
    2236                 :             :                            the insn, so fail in that combination of
    2237                 :             :                            cases.  */
    2238                 :        5430 :                         if (sregno < FIRST_PSEUDO_REGISTER
    2239                 :        5430 :                             && reg_mentioned_p (dest, PATTERN (q)))
    2240                 :             :                           failed = 1;
    2241                 :             :                         
    2242                 :             :                         /* Attempt to replace all uses.  */
    2243                 :        5430 :                         else if (!validate_replace_rtx (src, dest, q))
    2244                 :             :                           failed = 1;
    2245                 :             :                         
    2246                 :             :                         /* If this succeeded, but some part of the
    2247                 :             :                            register is still present, undo the
    2248                 :             :                            replacement.  */
    2249                 :        5430 :                         else if (sregno < FIRST_PSEUDO_REGISTER
    2250                 :        5430 :                                  && reg_overlap_mentioned_p (src, PATTERN (q)))
    2251                 :             :                           {
    2252                 :           0 :                             validate_replace_rtx (dest, src, q);
    2253                 :           0 :                             failed = 1;
    2254                 :             :                           }
    2255                 :             :                       }
    2256                 :             :                     
    2257                 :             :                     /* If DEST dies here, remove the death note and
    2258                 :             :                        save it for later.  Make sure ALL of DEST dies
    2259                 :             :                        here; again, this is overly conservative.  */
    2260                 :       21476 :                     if (! dest_death
    2261                 :       21476 :                         && (dest_death = find_regno_note (q, REG_DEAD, dregno)))
    2262                 :             :                       {
    2263                 :           1 :                         if (GET_MODE (XEXP (dest_death, 0)) == GET_MODE (dest))
    2264                 :           1 :                           remove_note (q, dest_death);
    2265                 :             :                         else
    2266                 :             :                           {
    2267                 :             :                             failed = 1;
    2268                 :             :                             dest_death = 0;
    2269                 :             :                           }
    2270                 :             :                       }
    2271                 :             :                   }
    2272                 :             :                 
    2273                 :        4371 :                 if (! failed)
    2274                 :             :                   {
    2275                 :             :                     /* Move death note of SRC from P to INSN.  */
    2276                 :        4371 :                     remove_note (p, note);
    2277                 :        4371 :                     XEXP (note, 1) = REG_NOTES (insn);
    2278                 :        4371 :                     REG_NOTES (insn) = note;
    2279                 :             :                   }
    2280                 :             :                 
    2281                 :             :                 /* DEST is also dead if INSN has a REG_UNUSED note for
    2282                 :             :                    DEST.  */
    2283                 :        4371 :                 if (! dest_death
    2284                 :        4371 :                     && (dest_death
    2285                 :        4370 :                         = find_regno_note (insn, REG_UNUSED, dregno)))
    2286                 :             :                   {
    2287                 :           0 :                     PUT_REG_NOTE_KIND (dest_death, REG_DEAD);
    2288                 :           0 :                     remove_note (insn, dest_death);
    2289                 :             :                   }
    2290                 :             :                 
    2291                 :             :                 /* Put death note of DEST on P if we saw it die.  */
    2292                 :        4371 :                 if (dest_death)
    2293                 :             :                   {
    2294                 :           1 :                     XEXP (dest_death, 1) = REG_NOTES (p);
    2295                 :           1 :                     REG_NOTES (p) = dest_death;
    2296                 :             :                   }
    2297                 :             :                 break;
    2298                 :             :               }
    2299                 :             :             
    2300                 :             :             /* If SRC is a hard register which is set or killed in
    2301                 :             :                some other way, we can't do this optimization.  */
    2302                 :     3616528 :             else if (sregno < FIRST_PSEUDO_REGISTER && dead_or_set_p (p, src))
    2303                 :             :               break;
    2304                 :             :           }
    2305                 :             :       }
    2306                 :             : }
    2307                 :             : 
    2308                 :             : 
    2309                 :             : 
    2310                 :             : /* Return nonzero if REGNO is a particularly bad choice for reloading X.  */
    2311                 :             : static bool
    2312                 :           0 : ira_bad_reload_regno_1 (int regno, rtx x)
    2313                 :             : {
    2314                 :           0 :   int x_regno, n, i;
    2315                 :           0 :   ira_allocno_t a;
    2316                 :           0 :   enum reg_class pref;
    2317                 :             : 
    2318                 :             :   /* We only deal with pseudo regs.  */
    2319                 :           0 :   if (! x || GET_CODE (x) != REG)
    2320                 :             :     return false;
    2321                 :             : 
    2322                 :           0 :   x_regno = REGNO (x);
    2323                 :           0 :   if (x_regno < FIRST_PSEUDO_REGISTER)
    2324                 :             :     return false;
    2325                 :             : 
    2326                 :             :   /* If the pseudo prefers REGNO explicitly, then do not consider
    2327                 :             :      REGNO a bad spill choice.  */
    2328                 :           0 :   pref = reg_preferred_class (x_regno);
    2329                 :           0 :   if (reg_class_size[pref] == 1)
    2330                 :           0 :     return !TEST_HARD_REG_BIT (reg_class_contents[pref], regno);
    2331                 :             : 
    2332                 :             :   /* If the pseudo conflicts with REGNO, then we consider REGNO a
    2333                 :             :      poor choice for a reload regno.  */
    2334                 :           0 :   a = ira_regno_allocno_map[x_regno];
    2335                 :           0 :   n = ALLOCNO_NUM_OBJECTS (a);
    2336                 :           0 :   for (i = 0; i < n; i++)
    2337                 :             :     {
    2338                 :           0 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2339                 :           0 :       if (TEST_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), regno))
    2340                 :             :         return true;
    2341                 :             :     }
    2342                 :             :   return false;
    2343                 :             : }
    2344                 :             : 
    2345                 :             : /* Return nonzero if REGNO is a particularly bad choice for reloading
    2346                 :             :    IN or OUT.  */
    2347                 :             : bool
    2348                 :           0 : ira_bad_reload_regno (int regno, rtx in, rtx out)
    2349                 :             : {
    2350                 :           0 :   return (ira_bad_reload_regno_1 (regno, in)
    2351                 :           0 :           || ira_bad_reload_regno_1 (regno, out));
    2352                 :             : }
    2353                 :             : 
    2354                 :             : /* Add register clobbers from asm statements.  */
    2355                 :             : static void
    2356                 :     1449150 : compute_regs_asm_clobbered (void)
    2357                 :             : {
    2358                 :     1449150 :   basic_block bb;
    2359                 :             : 
    2360                 :    14994012 :   FOR_EACH_BB_FN (bb, cfun)
    2361                 :             :     {
    2362                 :    13544862 :       rtx_insn *insn;
    2363                 :   157461277 :       FOR_BB_INSNS_REVERSE (bb, insn)
    2364                 :             :         {
    2365                 :   143916415 :           df_ref def;
    2366                 :             : 
    2367                 :   143916415 :           if (NONDEBUG_INSN_P (insn) && asm_noperands (PATTERN (insn)) >= 0)
    2368                 :      329661 :             FOR_EACH_INSN_DEF (def, insn)
    2369                 :             :               {
    2370                 :      220953 :                 unsigned int dregno = DF_REF_REGNO (def);
    2371                 :      220953 :                 if (HARD_REGISTER_NUM_P (dregno))
    2372                 :      314088 :                   add_to_hard_reg_set (&crtl->asm_clobbers,
    2373                 :      157044 :                                        GET_MODE (DF_REF_REAL_REG (def)),
    2374                 :             :                                        dregno);
    2375                 :             :               }
    2376                 :             :         }
    2377                 :             :     }
    2378                 :     1449150 : }
    2379                 :             : 
    2380                 :             : 
    2381                 :             : /* Set up ELIMINABLE_REGSET, IRA_NO_ALLOC_REGS, and
    2382                 :             :    REGS_EVER_LIVE.  */
    2383                 :             : void
    2384                 :     1449150 : ira_setup_eliminable_regset (void)
    2385                 :             : {
    2386                 :     1449150 :   int i;
    2387                 :     1449150 :   static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
    2388                 :     1449150 :   int fp_reg_count = hard_regno_nregs (HARD_FRAME_POINTER_REGNUM, Pmode);
    2389                 :             : 
    2390                 :             :   /* Setup is_leaf as frame_pointer_required may use it.  This function
    2391                 :             :      is called by sched_init before ira if scheduling is enabled.  */
    2392                 :     1449150 :   crtl->is_leaf = leaf_function_p ();
    2393                 :             : 
    2394                 :             :   /* FIXME: If EXIT_IGNORE_STACK is set, we will not save and restore
    2395                 :             :      sp for alloca.  So we can't eliminate the frame pointer in that
    2396                 :             :      case.  At some point, we should improve this by emitting the
    2397                 :             :      sp-adjusting insns for this case.  */
    2398                 :     1449150 :   frame_pointer_needed
    2399                 :     2898300 :     = (! flag_omit_frame_pointer
    2400                 :     1009926 :        || (cfun->calls_alloca && EXIT_IGNORE_STACK)
    2401                 :             :        /* We need the frame pointer to catch stack overflow exceptions if
    2402                 :             :           the stack pointer is moving (as for the alloca case just above).  */
    2403                 :     1001153 :        || (STACK_CHECK_MOVING_SP
    2404                 :     1001153 :            && flag_stack_check
    2405                 :          57 :            && flag_exceptions
    2406                 :          20 :            && cfun->can_throw_non_call_exceptions)
    2407                 :     1001149 :        || crtl->accesses_prior_frames
    2408                 :     1114648 :        || (SUPPORTS_STACK_ALIGNMENT && crtl->stack_realign_needed)
    2409                 :     2402054 :        || targetm.frame_pointer_required ());
    2410                 :             : 
    2411                 :             :     /* The chance that FRAME_POINTER_NEEDED is changed from inspecting
    2412                 :             :        RTL is very small.  So if we use frame pointer for RA and RTL
    2413                 :             :        actually prevents this, we will spill pseudos assigned to the
    2414                 :             :        frame pointer in LRA.  */
    2415                 :             : 
    2416                 :     1449150 :   if (frame_pointer_needed)
    2417                 :      992604 :     for (i = 0; i < fp_reg_count; i++)
    2418                 :      496302 :       df_set_regs_ever_live (HARD_FRAME_POINTER_REGNUM + i, true);
    2419                 :             :     
    2420                 :     1449150 :   ira_no_alloc_regs = no_unit_alloc_regs;
    2421                 :     1449150 :   CLEAR_HARD_REG_SET (eliminable_regset);
    2422                 :             : 
    2423                 :     1449150 :   compute_regs_asm_clobbered ();
    2424                 :             : 
    2425                 :             :   /* Build the regset of all eliminable registers and show we can't
    2426                 :             :      use those that we already know won't be eliminated.  */
    2427                 :     7245750 :   for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
    2428                 :             :     {
    2429                 :     5796600 :       bool cannot_elim
    2430                 :     5796600 :         = (! targetm.can_eliminate (eliminables[i].from, eliminables[i].to)
    2431                 :     5796600 :            || (eliminables[i].to == STACK_POINTER_REGNUM && frame_pointer_needed));
    2432                 :             : 
    2433                 :     5796600 :       if (!TEST_HARD_REG_BIT (crtl->asm_clobbers, eliminables[i].from))
    2434                 :             :         {
    2435                 :     5796600 :             SET_HARD_REG_BIT (eliminable_regset, eliminables[i].from);
    2436                 :             : 
    2437                 :     5796600 :             if (cannot_elim)
    2438                 :     1053054 :               SET_HARD_REG_BIT (ira_no_alloc_regs, eliminables[i].from);
    2439                 :             :         }
    2440                 :           0 :       else if (cannot_elim)
    2441                 :           0 :         error ("%s cannot be used in %<asm%> here",
    2442                 :             :                reg_names[eliminables[i].from]);
    2443                 :             :       else
    2444                 :           0 :         df_set_regs_ever_live (eliminables[i].from, true);
    2445                 :             :     }
    2446                 :             :   if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
    2447                 :             :     {
    2448                 :     2898300 :       for (i = 0; i < fp_reg_count; i++)
    2449                 :     1449150 :         if (global_regs[HARD_FRAME_POINTER_REGNUM + i])
    2450                 :             :           /* Nothing to do: the register is already treated as live
    2451                 :             :              where appropriate, and cannot be eliminated.  */
    2452                 :             :           ;
    2453                 :     1449129 :         else if (!TEST_HARD_REG_BIT (crtl->asm_clobbers,
    2454                 :             :                                      HARD_FRAME_POINTER_REGNUM + i))
    2455                 :             :           {
    2456                 :     1447846 :             SET_HARD_REG_BIT (eliminable_regset,
    2457                 :             :                               HARD_FRAME_POINTER_REGNUM + i);
    2458                 :     1447846 :             if (frame_pointer_needed)
    2459                 :      496300 :               SET_HARD_REG_BIT (ira_no_alloc_regs,
    2460                 :             :                                 HARD_FRAME_POINTER_REGNUM + i);
    2461                 :             :           }
    2462                 :        1283 :         else if (frame_pointer_needed)
    2463                 :           0 :           error ("%s cannot be used in %<asm%> here",
    2464                 :             :                  reg_names[HARD_FRAME_POINTER_REGNUM + i]);
    2465                 :             :         else
    2466                 :        1283 :           df_set_regs_ever_live (HARD_FRAME_POINTER_REGNUM + i, true);
    2467                 :             :     }
    2468                 :     1449150 : }
    2469                 :             : 
    2470                 :             : 
    2471                 :             : 
    2472                 :             : /* Vector of substitutions of register numbers,
    2473                 :             :    used to map pseudo regs into hardware regs.
    2474                 :             :    This is set up as a result of register allocation.
    2475                 :             :    Element N is the hard reg assigned to pseudo reg N,
    2476                 :             :    or is -1 if no hard reg was assigned.
    2477                 :             :    If N is a hard reg number, element N is N.  */
    2478                 :             : short *reg_renumber;
    2479                 :             : 
    2480                 :             : /* Set up REG_RENUMBER and CALLER_SAVE_NEEDED (used by reload) from
    2481                 :             :    the allocation found by IRA.  */
    2482                 :             : static void
    2483                 :     1421530 : setup_reg_renumber (void)
    2484                 :             : {
    2485                 :     1421530 :   int regno, hard_regno;
    2486                 :     1421530 :   ira_allocno_t a;
    2487                 :     1421530 :   ira_allocno_iterator ai;
    2488                 :             : 
    2489                 :     1421530 :   caller_save_needed = 0;
    2490                 :    35771694 :   FOR_EACH_ALLOCNO (a, ai)
    2491                 :             :     {
    2492                 :    34350164 :       if (ira_use_lra_p && ALLOCNO_CAP_MEMBER (a) != NULL)
    2493                 :     3492663 :         continue;
    2494                 :             :       /* There are no caps at this point.  */
    2495                 :    30857501 :       ira_assert (ALLOCNO_CAP_MEMBER (a) == NULL);
    2496                 :    30857501 :       if (! ALLOCNO_ASSIGNED_P (a))
    2497                 :             :         /* It can happen if A is not referenced but partially anticipated
    2498                 :             :            somewhere in a region.  */
    2499                 :           0 :         ALLOCNO_ASSIGNED_P (a) = true;
    2500                 :    30857501 :       ira_free_allocno_updated_costs (a);
    2501                 :    30857501 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2502                 :    30857501 :       regno = ALLOCNO_REGNO (a);
    2503                 :    30857501 :       reg_renumber[regno] = (hard_regno < 0 ? -1 : hard_regno);
    2504                 :    30857501 :       if (hard_regno >= 0)
    2505                 :             :         {
    2506                 :    27675730 :           int i, nwords;
    2507                 :    27675730 :           enum reg_class pclass;
    2508                 :    27675730 :           ira_object_t obj;
    2509                 :             :           
    2510                 :    27675730 :           pclass = ira_pressure_class_translate[REGNO_REG_CLASS (hard_regno)];
    2511                 :    27675730 :           nwords = ALLOCNO_NUM_OBJECTS (a);
    2512                 :    56434335 :           for (i = 0; i < nwords; i++)
    2513                 :             :             {
    2514                 :    28758605 :               obj = ALLOCNO_OBJECT (a, i);
    2515                 :    28758605 :               OBJECT_TOTAL_CONFLICT_HARD_REGS (obj)
    2516                 :    57517210 :                 |= ~reg_class_contents[pclass];
    2517                 :             :             }
    2518                 :    27675730 :           if (ira_need_caller_save_p (a, hard_regno))
    2519                 :             :             {
    2520                 :      456723 :               ira_assert (!optimize || flag_caller_saves
    2521                 :             :                           || (ALLOCNO_CALLS_CROSSED_NUM (a)
    2522                 :             :                               == ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a))
    2523                 :             :                           || regno >= ira_reg_equiv_len
    2524                 :             :                           || ira_equiv_no_lvalue_p (regno));
    2525                 :      456723 :               caller_save_needed = 1;
    2526                 :             :             }
    2527                 :             :         }
    2528                 :             :     }
    2529                 :     1421530 : }
    2530                 :             : 
    2531                 :             : /* Set up allocno assignment flags for further allocation
    2532                 :             :    improvements.  */
    2533                 :             : static void
    2534                 :           0 : setup_allocno_assignment_flags (void)
    2535                 :             : {
    2536                 :           0 :   int hard_regno;
    2537                 :           0 :   ira_allocno_t a;
    2538                 :           0 :   ira_allocno_iterator ai;
    2539                 :             : 
    2540                 :           0 :   FOR_EACH_ALLOCNO (a, ai)
    2541                 :             :     {
    2542                 :           0 :       if (! ALLOCNO_ASSIGNED_P (a))
    2543                 :             :         /* It can happen if A is not referenced but partially anticipated
    2544                 :             :            somewhere in a region.  */
    2545                 :           0 :         ira_free_allocno_updated_costs (a);
    2546                 :           0 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2547                 :             :       /* Don't assign hard registers to allocnos which are destination
    2548                 :             :          of removed store at the end of loop.  It has no sense to keep
    2549                 :             :          the same value in different hard registers.  It is also
    2550                 :             :          impossible to assign hard registers correctly to such
    2551                 :             :          allocnos because the cost info and info about intersected
    2552                 :             :          calls are incorrect for them.  */
    2553                 :           0 :       ALLOCNO_ASSIGNED_P (a) = (hard_regno >= 0
    2554                 :           0 :                                 || ALLOCNO_EMIT_DATA (a)->mem_optimized_dest_p
    2555                 :           0 :                                 || (ALLOCNO_MEMORY_COST (a)
    2556                 :           0 :                                     - ALLOCNO_CLASS_COST (a)) < 0);
    2557                 :           0 :       ira_assert
    2558                 :             :         (hard_regno < 0
    2559                 :             :          || ira_hard_reg_in_set_p (hard_regno, ALLOCNO_MODE (a),
    2560                 :             :                                    reg_class_contents[ALLOCNO_CLASS (a)]));
    2561                 :             :     }
    2562                 :           0 : }
    2563                 :             : 
    2564                 :             : /* Evaluate overall allocation cost and the costs for using hard
    2565                 :             :    registers and memory for allocnos.  */
    2566                 :             : static void
    2567                 :     1421530 : calculate_allocation_cost (void)
    2568                 :             : {
    2569                 :     1421530 :   int hard_regno, cost;
    2570                 :     1421530 :   ira_allocno_t a;
    2571                 :     1421530 :   ira_allocno_iterator ai;
    2572                 :             : 
    2573                 :     1421530 :   ira_overall_cost = ira_reg_cost = ira_mem_cost = 0;
    2574                 :    35771694 :   FOR_EACH_ALLOCNO (a, ai)
    2575                 :             :     {
    2576                 :    34350164 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2577                 :    34350164 :       ira_assert (hard_regno < 0
    2578                 :             :                   || (ira_hard_reg_in_set_p
    2579                 :             :                       (hard_regno, ALLOCNO_MODE (a),
    2580                 :             :                        reg_class_contents[ALLOCNO_CLASS (a)])));
    2581                 :    34350164 :       if (hard_regno < 0)
    2582                 :             :         {
    2583                 :     3568772 :           cost = ALLOCNO_MEMORY_COST (a);
    2584                 :     3568772 :           ira_mem_cost += cost;
    2585                 :             :         }
    2586                 :    30781392 :       else if (ALLOCNO_HARD_REG_COSTS (a) != NULL)
    2587                 :             :         {
    2588                 :     8152464 :           cost = (ALLOCNO_HARD_REG_COSTS (a)
    2589                 :             :                   [ira_class_hard_reg_index
    2590                 :     8152464 :                    [ALLOCNO_CLASS (a)][hard_regno]]);
    2591                 :     8152464 :           ira_reg_cost += cost;
    2592                 :             :         }
    2593                 :             :       else
    2594                 :             :         {
    2595                 :    22628928 :           cost = ALLOCNO_CLASS_COST (a);
    2596                 :    22628928 :           ira_reg_cost += cost;
    2597                 :             :         }
    2598                 :    34350164 :       ira_overall_cost += cost;
    2599                 :             :     }
    2600                 :             : 
    2601                 :     1421530 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    2602                 :             :     {
    2603                 :          95 :       fprintf (ira_dump_file,
    2604                 :             :                "+++Costs: overall %" PRId64
    2605                 :             :                ", reg %" PRId64
    2606                 :             :                ", mem %" PRId64
    2607                 :             :                ", ld %" PRId64
    2608                 :             :                ", st %" PRId64
    2609                 :             :                ", move %" PRId64,
    2610                 :             :                ira_overall_cost, ira_reg_cost, ira_mem_cost,
    2611                 :             :                ira_load_cost, ira_store_cost, ira_shuffle_cost);
    2612                 :          95 :       fprintf (ira_dump_file, "\n+++       move loops %d, new jumps %d\n",
    2613                 :             :                ira_move_loops_num, ira_additional_jumps_num);
    2614                 :             :     }
    2615                 :             : 
    2616                 :     1421530 : }
    2617                 :             : 
    2618                 :             : #ifdef ENABLE_IRA_CHECKING
    2619                 :             : /* Check the correctness of the allocation.  We do need this because
    2620                 :             :    of complicated code to transform more one region internal
    2621                 :             :    representation into one region representation.  */
    2622                 :             : static void
    2623                 :           0 : check_allocation (void)
    2624                 :             : {
    2625                 :           0 :   ira_allocno_t a;
    2626                 :           0 :   int hard_regno, nregs, conflict_nregs;
    2627                 :           0 :   ira_allocno_iterator ai;
    2628                 :             : 
    2629                 :           0 :   FOR_EACH_ALLOCNO (a, ai)
    2630                 :             :     {
    2631                 :           0 :       int n = ALLOCNO_NUM_OBJECTS (a);
    2632                 :           0 :       int i;
    2633                 :             : 
    2634                 :           0 :       if (ALLOCNO_CAP_MEMBER (a) != NULL
    2635                 :           0 :           || (hard_regno = ALLOCNO_HARD_REGNO (a)) < 0)
    2636                 :           0 :         continue;
    2637                 :           0 :       nregs = hard_regno_nregs (hard_regno, ALLOCNO_MODE (a));
    2638                 :           0 :       if (nregs == 1)
    2639                 :             :         /* We allocated a single hard register.  */
    2640                 :             :         n = 1;
    2641                 :           0 :       else if (n > 1)
    2642                 :             :         /* We allocated multiple hard registers, and we will test
    2643                 :             :            conflicts in a granularity of single hard regs.  */
    2644                 :           0 :         nregs = 1;
    2645                 :             : 
    2646                 :           0 :       for (i = 0; i < n; i++)
    2647                 :             :         {
    2648                 :           0 :           ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2649                 :           0 :           ira_object_t conflict_obj;
    2650                 :           0 :           ira_object_conflict_iterator oci;
    2651                 :           0 :           int this_regno = hard_regno;
    2652                 :           0 :           if (n > 1)
    2653                 :             :             {
    2654                 :           0 :               if (REG_WORDS_BIG_ENDIAN)
    2655                 :             :                 this_regno += n - i - 1;
    2656                 :             :               else
    2657                 :           0 :                 this_regno += i;
    2658                 :             :             }
    2659                 :           0 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    2660                 :             :             {
    2661                 :           0 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    2662                 :           0 :               int conflict_hard_regno = ALLOCNO_HARD_REGNO (conflict_a);
    2663                 :           0 :               if (conflict_hard_regno < 0)
    2664                 :           0 :                 continue;
    2665                 :           0 :               if (ira_soft_conflict (a, conflict_a))
    2666                 :           0 :                 continue;
    2667                 :             : 
    2668                 :           0 :               conflict_nregs = hard_regno_nregs (conflict_hard_regno,
    2669                 :           0 :                                                  ALLOCNO_MODE (conflict_a));
    2670                 :             : 
    2671                 :           0 :               if (ALLOCNO_NUM_OBJECTS (conflict_a) > 1
    2672                 :           0 :                   && conflict_nregs == ALLOCNO_NUM_OBJECTS (conflict_a))
    2673                 :             :                 {
    2674                 :           0 :                   if (REG_WORDS_BIG_ENDIAN)
    2675                 :             :                     conflict_hard_regno += (ALLOCNO_NUM_OBJECTS (conflict_a)
    2676                 :             :                                             - OBJECT_SUBWORD (conflict_obj) - 1);
    2677                 :             :                   else
    2678                 :           0 :                     conflict_hard_regno += OBJECT_SUBWORD (conflict_obj);
    2679                 :           0 :                   conflict_nregs = 1;
    2680                 :             :                 }
    2681                 :             : 
    2682                 :           0 :               if ((conflict_hard_regno <= this_regno
    2683                 :           0 :                  && this_regno < conflict_hard_regno + conflict_nregs)
    2684                 :           0 :                 || (this_regno <= conflict_hard_regno
    2685                 :           0 :                     && conflict_hard_regno < this_regno + nregs))
    2686                 :             :                 {
    2687                 :           0 :                   fprintf (stderr, "bad allocation for %d and %d\n",
    2688                 :             :                            ALLOCNO_REGNO (a), ALLOCNO_REGNO (conflict_a));
    2689                 :           0 :                   gcc_unreachable ();
    2690                 :             :                 }
    2691                 :             :             }
    2692                 :             :         }
    2693                 :             :     }
    2694                 :           0 : }
    2695                 :             : #endif
    2696                 :             : 
    2697                 :             : /* Allocate REG_EQUIV_INIT.  Set up it from IRA_REG_EQUIV which should
    2698                 :             :    be already calculated.  */
    2699                 :             : static void
    2700                 :     1421530 : setup_reg_equiv_init (void)
    2701                 :             : {
    2702                 :     1421530 :   int i;
    2703                 :     1421530 :   int max_regno = max_reg_num ();
    2704                 :             : 
    2705                 :   195198518 :   for (i = 0; i < max_regno; i++)
    2706                 :   192355458 :     reg_equiv_init (i) = ira_reg_equiv[i].init_insns;
    2707                 :     1421530 : }
    2708                 :             : 
    2709                 :             : /* Update equiv regno from movement of FROM_REGNO to TO_REGNO.  INSNS
    2710                 :             :    are insns which were generated for such movement.  It is assumed
    2711                 :             :    that FROM_REGNO and TO_REGNO always have the same value at the
    2712                 :             :    point of any move containing such registers. This function is used
    2713                 :             :    to update equiv info for register shuffles on the region borders
    2714                 :             :    and for caller save/restore insns.  */
    2715                 :             : void
    2716                 :     1893833 : ira_update_equiv_info_by_shuffle_insn (int to_regno, int from_regno, rtx_insn *insns)
    2717                 :             : {
    2718                 :     1893833 :   rtx_insn *insn;
    2719                 :     1893833 :   rtx x, note;
    2720                 :             : 
    2721                 :     1893833 :   if (! ira_reg_equiv[from_regno].defined_p
    2722                 :     1893833 :       && (! ira_reg_equiv[to_regno].defined_p
    2723                 :         942 :           || ((x = ira_reg_equiv[to_regno].memory) != NULL_RTX
    2724                 :         942 :               && ! MEM_READONLY_P (x))))
    2725                 :             :     return;
    2726                 :       32425 :   insn = insns;
    2727                 :       32425 :   if (NEXT_INSN (insn) != NULL_RTX)
    2728                 :             :     {
    2729                 :           0 :       if (! ira_reg_equiv[to_regno].defined_p)
    2730                 :             :         {
    2731                 :           0 :           ira_assert (ira_reg_equiv[to_regno].init_insns == NULL_RTX);
    2732                 :             :           return;
    2733                 :             :         }
    2734                 :           0 :       ira_reg_equiv[to_regno].defined_p = false;
    2735                 :           0 :       ira_reg_equiv[to_regno].caller_save_p = false;
    2736                 :           0 :       ira_reg_equiv[to_regno].memory
    2737                 :           0 :         = ira_reg_equiv[to_regno].constant
    2738                 :           0 :         = ira_reg_equiv[to_regno].invariant
    2739                 :           0 :         = ira_reg_equiv[to_regno].init_insns = NULL;
    2740                 :           0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2741                 :           0 :         fprintf (ira_dump_file,
    2742                 :             :                  "      Invalidating equiv info for reg %d\n", to_regno);
    2743                 :           0 :       return;
    2744                 :             :     }
    2745                 :             :   /* It is possible that FROM_REGNO still has no equivalence because
    2746                 :             :      in shuffles to_regno<-from_regno and from_regno<-to_regno the 2nd
    2747                 :             :      insn was not processed yet.  */
    2748                 :       32425 :   if (ira_reg_equiv[from_regno].defined_p)
    2749                 :             :     {
    2750                 :       32425 :       ira_reg_equiv[to_regno].defined_p = true;
    2751                 :       32425 :       if ((x = ira_reg_equiv[from_regno].memory) != NULL_RTX)
    2752                 :             :         {
    2753                 :       32189 :           ira_assert (ira_reg_equiv[from_regno].invariant == NULL_RTX
    2754                 :             :                       && ira_reg_equiv[from_regno].constant == NULL_RTX);
    2755                 :       32189 :           ira_assert (ira_reg_equiv[to_regno].memory == NULL_RTX
    2756                 :             :                       || rtx_equal_p (ira_reg_equiv[to_regno].memory, x));
    2757                 :       32189 :           ira_reg_equiv[to_regno].memory = x;
    2758                 :       32189 :           if (! MEM_READONLY_P (x))
    2759                 :             :             /* We don't add the insn to insn init list because memory
    2760                 :             :                equivalence is just to say what memory is better to use
    2761                 :             :                when the pseudo is spilled.  */
    2762                 :             :             return;
    2763                 :             :         }
    2764                 :         236 :       else if ((x = ira_reg_equiv[from_regno].constant) != NULL_RTX)
    2765                 :             :         {
    2766                 :         118 :           ira_assert (ira_reg_equiv[from_regno].invariant == NULL_RTX);
    2767                 :         118 :           ira_assert (ira_reg_equiv[to_regno].constant == NULL_RTX
    2768                 :             :                       || rtx_equal_p (ira_reg_equiv[to_regno].constant, x));
    2769                 :         118 :           ira_reg_equiv[to_regno].constant = x;
    2770                 :             :         }
    2771                 :             :       else
    2772                 :             :         {
    2773                 :         118 :           x = ira_reg_equiv[from_regno].invariant;
    2774                 :         118 :           ira_assert (x != NULL_RTX);
    2775                 :         118 :           ira_assert (ira_reg_equiv[to_regno].invariant == NULL_RTX
    2776                 :             :                       || rtx_equal_p (ira_reg_equiv[to_regno].invariant, x));
    2777                 :         118 :           ira_reg_equiv[to_regno].invariant = x;
    2778                 :             :         }
    2779                 :         265 :       if (find_reg_note (insn, REG_EQUIV, x) == NULL_RTX)
    2780                 :             :         {
    2781                 :         265 :           note = set_unique_reg_note (insn, REG_EQUIV, copy_rtx (x));
    2782                 :         265 :           gcc_assert (note != NULL_RTX);
    2783                 :         265 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2784                 :             :             {
    2785                 :           0 :               fprintf (ira_dump_file,
    2786                 :             :                        "      Adding equiv note to insn %u for reg %d ",
    2787                 :           0 :                        INSN_UID (insn), to_regno);
    2788                 :           0 :               dump_value_slim (ira_dump_file, x, 1);
    2789                 :           0 :               fprintf (ira_dump_file, "\n");
    2790                 :             :             }
    2791                 :             :         }
    2792                 :             :     }
    2793                 :         265 :   ira_reg_equiv[to_regno].init_insns
    2794                 :         530 :     = gen_rtx_INSN_LIST (VOIDmode, insn,
    2795                 :         265 :                          ira_reg_equiv[to_regno].init_insns);
    2796                 :         265 :   if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2797                 :           0 :     fprintf (ira_dump_file,
    2798                 :             :              "      Adding equiv init move insn %u to reg %d\n",
    2799                 :           0 :              INSN_UID (insn), to_regno);
    2800                 :             : }
    2801                 :             : 
    2802                 :             : /* Fix values of array REG_EQUIV_INIT after live range splitting done
    2803                 :             :    by IRA.  */
    2804                 :             : static void
    2805                 :     1992952 : fix_reg_equiv_init (void)
    2806                 :             : {
    2807                 :     1992952 :   int max_regno = max_reg_num ();
    2808                 :     1992952 :   int i, new_regno, max;
    2809                 :     1992952 :   rtx set;
    2810                 :     1992952 :   rtx_insn_list *x, *next, *prev;
    2811                 :     1992952 :   rtx_insn *insn;
    2812                 :             : 
    2813                 :     1992952 :   if (max_regno_before_ira < max_regno)
    2814                 :             :     {
    2815                 :      485605 :       max = vec_safe_length (reg_equivs);
    2816                 :      485605 :       grow_reg_equivs ();
    2817                 :    44890122 :       for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
    2818                 :    44404517 :         for (prev = NULL, x = reg_equiv_init (i);
    2819                 :    48599747 :              x != NULL_RTX;
    2820                 :             :              x = next)
    2821                 :             :           {
    2822                 :     4195230 :             next = x->next ();
    2823                 :     4195230 :             insn = x->insn ();
    2824                 :     4195230 :             set = single_set (insn);
    2825                 :     4195230 :             ira_assert (set != NULL_RTX
    2826                 :             :                         && (REG_P (SET_DEST (set)) || REG_P (SET_SRC (set))));
    2827                 :     4195230 :             if (REG_P (SET_DEST (set))
    2828                 :     4195230 :                 && ((int) REGNO (SET_DEST (set)) == i
    2829                 :           0 :                     || (int) ORIGINAL_REGNO (SET_DEST (set)) == i))
    2830                 :             :               new_regno = REGNO (SET_DEST (set));
    2831                 :      418889 :             else if (REG_P (SET_SRC (set))
    2832                 :      418889 :                      && ((int) REGNO (SET_SRC (set)) == i
    2833                 :           0 :                          || (int) ORIGINAL_REGNO (SET_SRC (set)) == i))
    2834                 :             :               new_regno = REGNO (SET_SRC (set));
    2835                 :             :             else
    2836                 :           0 :               gcc_unreachable ();
    2837                 :     4195230 :             if (new_regno == i)
    2838                 :             :               prev = x;
    2839                 :             :             else
    2840                 :             :               {
    2841                 :             :                 /* Remove the wrong list element.  */
    2842                 :           0 :                 if (prev == NULL_RTX)
    2843                 :           0 :                   reg_equiv_init (i) = next;
    2844                 :             :                 else
    2845                 :           0 :                   XEXP (prev, 1) = next;
    2846                 :           0 :                 XEXP (x, 1) = reg_equiv_init (new_regno);
    2847                 :           0 :                 reg_equiv_init (new_regno) = x;
    2848                 :             :               }
    2849                 :             :           }
    2850                 :             :     }
    2851                 :     1992952 : }
    2852                 :             : 
    2853                 :             : #ifdef ENABLE_IRA_CHECKING
    2854                 :             : /* Print redundant memory-memory copies.  */
    2855                 :             : static void
    2856                 :      996476 : print_redundant_copies (void)
    2857                 :             : {
    2858                 :      996476 :   int hard_regno;
    2859                 :      996476 :   ira_allocno_t a;
    2860                 :      996476 :   ira_copy_t cp, next_cp;
    2861                 :      996476 :   ira_allocno_iterator ai;
    2862                 :             : 
    2863                 :    24258495 :   FOR_EACH_ALLOCNO (a, ai)
    2864                 :             :     {
    2865                 :    23262019 :       if (ALLOCNO_CAP_MEMBER (a) != NULL)
    2866                 :             :         /* It is a cap.  */
    2867                 :     3492663 :         continue;
    2868                 :    19769356 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2869                 :    19769356 :       if (hard_regno >= 0)
    2870                 :    16675991 :         continue;
    2871                 :     4003261 :       for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    2872                 :      909896 :         if (cp->first == a)
    2873                 :      359864 :           next_cp = cp->next_first_allocno_copy;
    2874                 :             :         else
    2875                 :             :           {
    2876                 :      550032 :             next_cp = cp->next_second_allocno_copy;
    2877                 :      550032 :             if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL
    2878                 :           2 :                 && cp->insn != NULL_RTX
    2879                 :           0 :                 && ALLOCNO_HARD_REGNO (cp->first) == hard_regno)
    2880                 :           0 :               fprintf (ira_dump_file,
    2881                 :             :                        "        Redundant move from %d(freq %d):%d\n",
    2882                 :           0 :                        INSN_UID (cp->insn), cp->freq, hard_regno);
    2883                 :             :           }
    2884                 :             :     }
    2885                 :      996476 : }
    2886                 :             : #endif
    2887                 :             : 
    2888                 :             : /* Setup preferred and alternative classes for new pseudo-registers
    2889                 :             :    created by IRA starting with START.  */
    2890                 :             : static void
    2891                 :     1030183 : setup_preferred_alternate_classes_for_new_pseudos (int start)
    2892                 :             : {
    2893                 :     1030183 :   int i, old_regno;
    2894                 :     1030183 :   int max_regno = max_reg_num ();
    2895                 :             : 
    2896                 :     2059897 :   for (i = start; i < max_regno; i++)
    2897                 :             :     {
    2898                 :     1029714 :       old_regno = ORIGINAL_REGNO (regno_reg_rtx[i]);
    2899                 :     1029714 :       ira_assert (i != old_regno);
    2900                 :     1029714 :       setup_reg_classes (i, reg_preferred_class (old_regno),
    2901                 :             :                          reg_alternate_class (old_regno),
    2902                 :             :                          reg_allocno_class (old_regno));
    2903                 :     1029714 :       if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
    2904                 :           0 :         fprintf (ira_dump_file,
    2905                 :             :                  "    New r%d: setting preferred %s, alternative %s\n",
    2906                 :           0 :                  i, reg_class_names[reg_preferred_class (old_regno)],
    2907                 :           0 :                  reg_class_names[reg_alternate_class (old_regno)]);
    2908                 :             :     }
    2909                 :     1030183 : }
    2910                 :             : 
    2911                 :             : 
    2912                 :             : /* The number of entries allocated in reg_info.  */
    2913                 :             : static int allocated_reg_info_size;
    2914                 :             : 
    2915                 :             : /* Regional allocation can create new pseudo-registers.  This function
    2916                 :             :    expands some arrays for pseudo-registers.  */
    2917                 :             : static void
    2918                 :     1030183 : expand_reg_info (void)
    2919                 :             : {
    2920                 :     1030183 :   int i;
    2921                 :     1030183 :   int size = max_reg_num ();
    2922                 :             : 
    2923                 :     1030183 :   resize_reg_info ();
    2924                 :     2059897 :   for (i = allocated_reg_info_size; i < size; i++)
    2925                 :     1029714 :     setup_reg_classes (i, GENERAL_REGS, ALL_REGS, GENERAL_REGS);
    2926                 :     1030183 :   setup_preferred_alternate_classes_for_new_pseudos (allocated_reg_info_size);
    2927                 :     1030183 :   allocated_reg_info_size = size;
    2928                 :     1030183 : }
    2929                 :             : 
    2930                 :             : /* Return TRUE if there is too high register pressure in the function.
    2931                 :             :    It is used to decide when stack slot sharing is worth to do.  */
    2932                 :             : static bool
    2933                 :     1421530 : too_high_register_pressure_p (void)
    2934                 :             : {
    2935                 :     1421530 :   int i;
    2936                 :     1421530 :   enum reg_class pclass;
    2937                 :             : 
    2938                 :     7144786 :   for (i = 0; i < ira_pressure_classes_num; i++)
    2939                 :             :     {
    2940                 :     5723258 :       pclass = ira_pressure_classes[i];
    2941                 :     5723258 :       if (ira_loop_tree_root->reg_pressure[pclass] > 10000)
    2942                 :             :         return true;
    2943                 :             :     }
    2944                 :             :   return false;
    2945                 :             : }
    2946                 :             : 
    2947                 :             : 
    2948                 :             : 
    2949                 :             : /* Indicate that hard register number FROM was eliminated and replaced with
    2950                 :             :    an offset from hard register number TO.  The status of hard registers live
    2951                 :             :    at the start of a basic block is updated by replacing a use of FROM with
    2952                 :             :    a use of TO.  */
    2953                 :             : 
    2954                 :             : void
    2955                 :           0 : mark_elimination (int from, int to)
    2956                 :             : {
    2957                 :           0 :   basic_block bb;
    2958                 :           0 :   bitmap r;
    2959                 :             : 
    2960                 :           0 :   FOR_EACH_BB_FN (bb, cfun)
    2961                 :             :     {
    2962                 :           0 :       r = DF_LR_IN (bb);
    2963                 :           0 :       if (bitmap_bit_p (r, from))
    2964                 :             :         {
    2965                 :           0 :           bitmap_clear_bit (r, from);
    2966                 :           0 :           bitmap_set_bit (r, to);
    2967                 :             :         }
    2968                 :           0 :       if (! df_live)
    2969                 :           0 :         continue;
    2970                 :           0 :       r = DF_LIVE_IN (bb);
    2971                 :           0 :       if (bitmap_bit_p (r, from))
    2972                 :             :         {
    2973                 :           0 :           bitmap_clear_bit (r, from);
    2974                 :           0 :           bitmap_set_bit (r, to);
    2975                 :             :         }
    2976                 :             :     }
    2977                 :           0 : }
    2978                 :             : 
    2979                 :             : 
    2980                 :             : 
    2981                 :             : /* The length of the following array.  */
    2982                 :             : int ira_reg_equiv_len;
    2983                 :             : 
    2984                 :             : /* Info about equiv. info for each register.  */
    2985                 :             : struct ira_reg_equiv_s *ira_reg_equiv;
    2986                 :             : 
    2987                 :             : /* Expand ira_reg_equiv if necessary.  */
    2988                 :             : void
    2989                 :    11320851 : ira_expand_reg_equiv (void)
    2990                 :             : {
    2991                 :    11320851 :   int old = ira_reg_equiv_len;
    2992                 :             : 
    2993                 :    11320851 :   if (ira_reg_equiv_len > max_reg_num ())
    2994                 :             :     return;
    2995                 :     1424218 :   ira_reg_equiv_len = max_reg_num () * 3 / 2 + 1;
    2996                 :     1424218 :   ira_reg_equiv
    2997                 :     2848436 :     = (struct ira_reg_equiv_s *) xrealloc (ira_reg_equiv,
    2998                 :     1424218 :                                          ira_reg_equiv_len
    2999                 :             :                                          * sizeof (struct ira_reg_equiv_s));
    3000                 :     1424218 :   gcc_assert (old < ira_reg_equiv_len);
    3001                 :     1424218 :   memset (ira_reg_equiv + old, 0,
    3002                 :     1424218 :           sizeof (struct ira_reg_equiv_s) * (ira_reg_equiv_len - old));
    3003                 :             : }
    3004                 :             : 
    3005                 :             : static void
    3006                 :     1421530 : init_reg_equiv (void)
    3007                 :             : {
    3008                 :     1421530 :   ira_reg_equiv_len = 0;
    3009                 :     1421530 :   ira_reg_equiv = NULL;
    3010                 :           0 :   ira_expand_reg_equiv ();
    3011                 :           0 : }
    3012                 :             : 
    3013                 :             : static void
    3014                 :     1421530 : finish_reg_equiv (void)
    3015                 :             : {
    3016                 :     1421530 :   free (ira_reg_equiv);
    3017                 :           0 : }
    3018                 :             : 
    3019                 :             : 
    3020                 :             : 
    3021                 :             : struct equivalence
    3022                 :             : {
    3023                 :             :   /* Set when a REG_EQUIV note is found or created.  Use to
    3024                 :             :      keep track of what memory accesses might be created later,
    3025                 :             :      e.g. by reload.  */
    3026                 :             :   rtx replacement;
    3027                 :             :   rtx *src_p;
    3028                 :             : 
    3029                 :             :   /* The list of each instruction which initializes this register.
    3030                 :             : 
    3031                 :             :      NULL indicates we know nothing about this register's equivalence
    3032                 :             :      properties.
    3033                 :             : 
    3034                 :             :      An INSN_LIST with a NULL insn indicates this pseudo is already
    3035                 :             :      known to not have a valid equivalence.  */
    3036                 :             :   rtx_insn_list *init_insns;
    3037                 :             : 
    3038                 :             :   /* Loop depth is used to recognize equivalences which appear
    3039                 :             :      to be present within the same loop (or in an inner loop).  */
    3040                 :             :   short loop_depth;
    3041                 :             :   /* Nonzero if this had a preexisting REG_EQUIV note.  */
    3042                 :             :   unsigned char is_arg_equivalence : 1;
    3043                 :             :   /* Set when an attempt should be made to replace a register
    3044                 :             :      with the associated src_p entry.  */
    3045                 :             :   unsigned char replace : 1;
    3046                 :             :   /* Set if this register has no known equivalence.  */
    3047                 :             :   unsigned char no_equiv : 1;
    3048                 :             :   /* Set if this register is mentioned in a paradoxical subreg.  */
    3049                 :             :   unsigned char pdx_subregs : 1;
    3050                 :             : };
    3051                 :             : 
    3052                 :             : /* reg_equiv[N] (where N is a pseudo reg number) is the equivalence
    3053                 :             :    structure for that register.  */
    3054                 :             : static struct equivalence *reg_equiv;
    3055                 :             : 
    3056                 :             : /* Used for communication between the following two functions.  */
    3057                 :             : struct equiv_mem_data
    3058                 :             : {
    3059                 :             :   /* A MEM that we wish to ensure remains unchanged.  */
    3060                 :             :   rtx equiv_mem;
    3061                 :             : 
    3062                 :             :   /* Set true if EQUIV_MEM is modified.  */
    3063                 :             :   bool equiv_mem_modified;
    3064                 :             : };
    3065                 :             : 
    3066                 :             : /* If EQUIV_MEM is modified by modifying DEST, indicate that it is modified.
    3067                 :             :    Called via note_stores.  */
    3068                 :             : static void
    3069                 :    12414961 : validate_equiv_mem_from_store (rtx dest, const_rtx set ATTRIBUTE_UNUSED,
    3070                 :             :                                void *data)
    3071                 :             : {
    3072                 :    12414961 :   struct equiv_mem_data *info = (struct equiv_mem_data *) data;
    3073                 :             : 
    3074                 :    12414961 :   if ((REG_P (dest)
    3075                 :     9299624 :        && reg_overlap_mentioned_p (dest, info->equiv_mem))
    3076                 :    21700520 :       || (MEM_P (dest)
    3077                 :     3085246 :           && anti_dependence (info->equiv_mem, dest)))
    3078                 :      203593 :     info->equiv_mem_modified = true;
    3079                 :    12414961 : }
    3080                 :             : 
    3081                 :             : static bool equiv_init_varies_p (rtx x);
    3082                 :             : 
    3083                 :             : enum valid_equiv { valid_none, valid_combine, valid_reload };
    3084                 :             : 
    3085                 :             : /* Verify that no store between START and the death of REG invalidates
    3086                 :             :    MEMREF.  MEMREF is invalidated by modifying a register used in MEMREF,
    3087                 :             :    by storing into an overlapping memory location, or with a non-const
    3088                 :             :    CALL_INSN.
    3089                 :             : 
    3090                 :             :    Return VALID_RELOAD if MEMREF remains valid for both reload and
    3091                 :             :    combine_and_move insns, VALID_COMBINE if only valid for
    3092                 :             :    combine_and_move_insns, and VALID_NONE otherwise.  */
    3093                 :             : static enum valid_equiv
    3094                 :     3565104 : validate_equiv_mem (rtx_insn *start, rtx reg, rtx memref)
    3095                 :             : {
    3096                 :     3565104 :   rtx_insn *insn;
    3097                 :     3565104 :   rtx note;
    3098                 :     3565104 :   struct equiv_mem_data info = { memref, false };
    3099                 :     3565104 :   enum valid_equiv ret = valid_reload;
    3100                 :             : 
    3101                 :             :   /* If the memory reference has side effects or is volatile, it isn't a
    3102                 :             :      valid equivalence.  */
    3103                 :     3565104 :   if (side_effects_p (memref))
    3104                 :             :     return valid_none;
    3105                 :             : 
    3106                 :    18553887 :   for (insn = start; insn; insn = NEXT_INSN (insn))
    3107                 :             :     {
    3108                 :    18553693 :       if (!INSN_P (insn))
    3109                 :     1353735 :         continue;
    3110                 :             : 
    3111                 :    17199958 :       if (find_reg_note (insn, REG_DEAD, reg))
    3112                 :     2523800 :         return ret;
    3113                 :             : 
    3114                 :    14676158 :       if (CALL_P (insn))
    3115                 :             :         {
    3116                 :             :           /* We can combine a reg def from one insn into a reg use in
    3117                 :             :              another over a call if the memory is readonly or the call
    3118                 :             :              const/pure.  However, we can't set reg_equiv notes up for
    3119                 :             :              reload over any call.  The problem is the equivalent form
    3120                 :             :              may reference a pseudo which gets assigned a call
    3121                 :             :              clobbered hard reg.  When we later replace REG with its
    3122                 :             :              equivalent form, the value in the call-clobbered reg has
    3123                 :             :              been changed and all hell breaks loose.  */
    3124                 :       87812 :           ret = valid_combine;
    3125                 :       87812 :           if (!MEM_READONLY_P (memref)
    3126                 :       87812 :               && (!RTL_CONST_OR_PURE_CALL_P (insn)
    3127                 :        8351 :                   || equiv_init_varies_p (XEXP (memref, 0))))
    3128                 :       81744 :             return valid_none;
    3129                 :             :         }
    3130                 :             : 
    3131                 :    14594414 :       note_stores (insn, validate_equiv_mem_from_store, &info);
    3132                 :    14594414 :       if (info.equiv_mem_modified)
    3133                 :             :         return valid_none;
    3134                 :             : 
    3135                 :             :       /* If a register mentioned in MEMREF is modified via an
    3136                 :             :          auto-increment, we lose the equivalence.  Do the same if one
    3137                 :             :          dies; although we could extend the life, it doesn't seem worth
    3138                 :             :          the trouble.  */
    3139                 :             : 
    3140                 :    20241222 :       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    3141                 :     6421282 :         if ((REG_NOTE_KIND (note) == REG_INC
    3142                 :     6421282 :              || REG_NOTE_KIND (note) == REG_DEAD)
    3143                 :     4887922 :             && REG_P (XEXP (note, 0))
    3144                 :    11309204 :             && reg_overlap_mentioned_p (XEXP (note, 0), memref))
    3145                 :             :           return valid_none;
    3146                 :             :     }
    3147                 :             : 
    3148                 :             :   return valid_none;
    3149                 :             : }
    3150                 :             : 
    3151                 :             : /* Returns false if X is known to be invariant.  */
    3152                 :             : static bool
    3153                 :      853850 : equiv_init_varies_p (rtx x)
    3154                 :             : {
    3155                 :      853850 :   RTX_CODE code = GET_CODE (x);
    3156                 :      853850 :   int i;
    3157                 :      853850 :   const char *fmt;
    3158                 :             : 
    3159                 :      853850 :   switch (code)
    3160                 :             :     {
    3161                 :      228667 :     case MEM:
    3162                 :      228667 :       return !MEM_READONLY_P (x) || equiv_init_varies_p (XEXP (x, 0));
    3163                 :             : 
    3164                 :             :     case CONST:
    3165                 :             :     CASE_CONST_ANY:
    3166                 :             :     case SYMBOL_REF:
    3167                 :             :     case LABEL_REF:
    3168                 :             :       return false;
    3169                 :             : 
    3170                 :      180988 :     case REG:
    3171                 :      180988 :       return reg_equiv[REGNO (x)].replace == 0 && rtx_varies_p (x, 0);
    3172                 :             : 
    3173                 :           0 :     case ASM_OPERANDS:
    3174                 :           0 :       if (MEM_VOLATILE_P (x))
    3175                 :             :         return true;
    3176                 :             : 
    3177                 :             :       /* Fall through.  */
    3178                 :             : 
    3179                 :      156979 :     default:
    3180                 :      156979 :       break;
    3181                 :             :     }
    3182                 :             : 
    3183                 :      156979 :   fmt = GET_RTX_FORMAT (code);
    3184                 :      371554 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3185                 :      240256 :     if (fmt[i] == 'e')
    3186                 :             :       {
    3187                 :      238639 :         if (equiv_init_varies_p (XEXP (x, i)))
    3188                 :             :           return true;
    3189                 :             :       }
    3190                 :        1617 :     else if (fmt[i] == 'E')
    3191                 :             :       {
    3192                 :             :         int j;
    3193                 :        3720 :         for (j = 0; j < XVECLEN (x, i); j++)
    3194                 :        3370 :           if (equiv_init_varies_p (XVECEXP (x, i, j)))
    3195                 :             :             return true;
    3196                 :             :       }
    3197                 :             : 
    3198                 :             :   return false;
    3199                 :             : }
    3200                 :             : 
    3201                 :             : /* Returns true if X (used to initialize register REGNO) is movable.
    3202                 :             :    X is only movable if the registers it uses have equivalent initializations
    3203                 :             :    which appear to be within the same loop (or in an inner loop) and movable
    3204                 :             :    or if they are not candidates for local_alloc and don't vary.  */
    3205                 :             : static bool
    3206                 :     9975330 : equiv_init_movable_p (rtx x, int regno)
    3207                 :             : {
    3208                 :    12768709 :   int i, j;
    3209                 :    12768709 :   const char *fmt;
    3210                 :    12768709 :   enum rtx_code code = GET_CODE (x);
    3211                 :             : 
    3212                 :    12768709 :   switch (code)
    3213                 :             :     {
    3214                 :     2793379 :     case SET:
    3215                 :     2793379 :       return equiv_init_movable_p (SET_SRC (x), regno);
    3216                 :             : 
    3217                 :             :     case CLOBBER:
    3218                 :             :       return false;
    3219                 :             : 
    3220                 :             :     case PRE_INC:
    3221                 :             :     case PRE_DEC:
    3222                 :             :     case POST_INC:
    3223                 :             :     case POST_DEC:
    3224                 :             :     case PRE_MODIFY:
    3225                 :             :     case POST_MODIFY:
    3226                 :             :       return false;
    3227                 :             : 
    3228                 :     1701635 :     case REG:
    3229                 :     1701635 :       return ((reg_equiv[REGNO (x)].loop_depth >= reg_equiv[regno].loop_depth
    3230                 :     1281876 :                && reg_equiv[REGNO (x)].replace)
    3231                 :     2889781 :               || (REG_BASIC_BLOCK (REGNO (x)) < NUM_FIXED_BLOCKS
    3232                 :     1491282 :                   && ! rtx_varies_p (x, 0)));
    3233                 :             : 
    3234                 :             :     case UNSPEC_VOLATILE:
    3235                 :             :       return false;
    3236                 :             : 
    3237                 :           0 :     case ASM_OPERANDS:
    3238                 :           0 :       if (MEM_VOLATILE_P (x))
    3239                 :             :         return false;
    3240                 :             : 
    3241                 :             :       /* Fall through.  */
    3242                 :             : 
    3243                 :     7659422 :     default:
    3244                 :     7659422 :       break;
    3245                 :             :     }
    3246                 :             : 
    3247                 :     7659422 :   fmt = GET_RTX_FORMAT (code);
    3248                 :    18127566 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3249                 :    12289224 :     switch (fmt[i])
    3250                 :             :       {
    3251                 :     5619518 :       case 'e':
    3252                 :     5619518 :         if (! equiv_init_movable_p (XEXP (x, i), regno))
    3253                 :             :           return false;
    3254                 :             :         break;
    3255                 :      752483 :       case 'E':
    3256                 :     1086370 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3257                 :      948160 :           if (! equiv_init_movable_p (XVECEXP (x, i, j), regno))
    3258                 :             :             return false;
    3259                 :             :         break;
    3260                 :             :       }
    3261                 :             : 
    3262                 :             :   return true;
    3263                 :             : }
    3264                 :             : 
    3265                 :             : static bool memref_referenced_p (rtx memref, rtx x, bool read_p);
    3266                 :             : 
    3267                 :             : /* Auxiliary function for memref_referenced_p.  Process setting X for
    3268                 :             :    MEMREF store.  */
    3269                 :             : static bool
    3270                 :      628692 : process_set_for_memref_referenced_p (rtx memref, rtx x)
    3271                 :             : {
    3272                 :             :   /* If we are setting a MEM, it doesn't count (its address does), but any
    3273                 :             :      other SET_DEST that has a MEM in it is referencing the MEM.  */
    3274                 :      628692 :   if (MEM_P (x))
    3275                 :             :     {
    3276                 :      509244 :       if (memref_referenced_p (memref, XEXP (x, 0), true))
    3277                 :             :         return true;
    3278                 :             :     }
    3279                 :      119448 :   else if (memref_referenced_p (memref, x, false))
    3280                 :             :     return true;
    3281                 :             :   
    3282                 :             :   return false;
    3283                 :             : }
    3284                 :             : 
    3285                 :             : /* TRUE if X references a memory location (as a read if READ_P) that
    3286                 :             :    would be affected by a store to MEMREF.  */
    3287                 :             : static bool
    3288                 :     3013407 : memref_referenced_p (rtx memref, rtx x, bool read_p)
    3289                 :             : {
    3290                 :     3013407 :   int i, j;
    3291                 :     3013407 :   const char *fmt;
    3292                 :     3013407 :   enum rtx_code code = GET_CODE (x);
    3293                 :             : 
    3294                 :     3013407 :   switch (code)
    3295                 :             :     {
    3296                 :             :     case CONST:
    3297                 :             :     case LABEL_REF:
    3298                 :             :     case SYMBOL_REF:
    3299                 :             :     CASE_CONST_ANY:
    3300                 :             :     case PC:
    3301                 :             :     case HIGH:
    3302                 :             :     case LO_SUM:
    3303                 :             :       return false;
    3304                 :             : 
    3305                 :     1213665 :     case REG:
    3306                 :     1213665 :       return (reg_equiv[REGNO (x)].replacement
    3307                 :     1275059 :               && memref_referenced_p (memref,
    3308                 :       61394 :                                       reg_equiv[REGNO (x)].replacement, read_p));
    3309                 :             : 
    3310                 :       78479 :     case MEM:
    3311                 :             :       /* Memory X might have another effective type than MEMREF.  */
    3312                 :       78479 :       if (read_p || true_dependence (memref, VOIDmode, x))
    3313                 :       71190 :         return true;
    3314                 :             :       break;
    3315                 :             : 
    3316                 :      613592 :     case SET:
    3317                 :      613592 :       if (process_set_for_memref_referenced_p (memref, SET_DEST (x)))
    3318                 :             :         return true;
    3319                 :             : 
    3320                 :      598769 :       return memref_referenced_p (memref, SET_SRC (x), true);
    3321                 :             : 
    3322                 :       15100 :     case CLOBBER:
    3323                 :       15100 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3324                 :             :         return true;
    3325                 :             : 
    3326                 :             :       return false;
    3327                 :             : 
    3328                 :           0 :     case PRE_DEC:
    3329                 :           0 :     case POST_DEC:
    3330                 :           0 :     case PRE_INC:
    3331                 :           0 :     case POST_INC:
    3332                 :           0 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3333                 :             :         return true;
    3334                 :             : 
    3335                 :           0 :       return memref_referenced_p (memref, XEXP (x, 0), true);
    3336                 :             :       
    3337                 :           0 :     case POST_MODIFY:
    3338                 :           0 :     case PRE_MODIFY:
    3339                 :             :       /* op0 = op0 + op1 */
    3340                 :           0 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3341                 :             :         return true;
    3342                 :             : 
    3343                 :           0 :       if (memref_referenced_p (memref, XEXP (x, 0), true))
    3344                 :             :         return true;
    3345                 :             : 
    3346                 :           0 :       return memref_referenced_p (memref, XEXP (x, 1), true);
    3347                 :             : 
    3348                 :             :     default:
    3349                 :             :       break;
    3350                 :             :     }
    3351                 :             : 
    3352                 :      570403 :   fmt = GET_RTX_FORMAT (code);
    3353                 :     1643387 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3354                 :     1103657 :     switch (fmt[i])
    3355                 :             :       {
    3356                 :     1070031 :       case 'e':
    3357                 :     1070031 :         if (memref_referenced_p (memref, XEXP (x, i), read_p))
    3358                 :             :           return true;
    3359                 :             :         break;
    3360                 :       19692 :       case 'E':
    3361                 :       57982 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3362                 :       41177 :           if (memref_referenced_p (memref, XVECEXP (x, i, j), read_p))
    3363                 :             :             return true;
    3364                 :             :         break;
    3365                 :             :       }
    3366                 :             : 
    3367                 :             :   return false;
    3368                 :             : }
    3369                 :             : 
    3370                 :             : /* TRUE if some insn in the range (START, END] references a memory location
    3371                 :             :    that would be affected by a store to MEMREF.
    3372                 :             : 
    3373                 :             :    Callers should not call this routine if START is after END in the
    3374                 :             :    RTL chain.  */
    3375                 :             : 
    3376                 :             : static bool
    3377                 :      493378 : memref_used_between_p (rtx memref, rtx_insn *start, rtx_insn *end)
    3378                 :             : {
    3379                 :      493378 :   rtx_insn *insn;
    3380                 :             : 
    3381                 :     1595470 :   for (insn = NEXT_INSN (start);
    3382                 :     3175781 :        insn && insn != NEXT_INSN (end);
    3383                 :     1102092 :        insn = NEXT_INSN (insn))
    3384                 :             :     {
    3385                 :     1173282 :       if (!NONDEBUG_INSN_P (insn))
    3386                 :      559938 :         continue;
    3387                 :             : 
    3388                 :      613344 :       if (memref_referenced_p (memref, PATTERN (insn), false))
    3389                 :             :         return true;
    3390                 :             : 
    3391                 :             :       /* Nonconst functions may access memory.  */
    3392                 :      542154 :       if (CALL_P (insn) && (! RTL_CONST_CALL_P (insn)))
    3393                 :             :         return true;
    3394                 :             :     }
    3395                 :             : 
    3396                 :      422188 :   gcc_assert (insn == NEXT_INSN (end));
    3397                 :             :   return false;
    3398                 :             : }
    3399                 :             : 
    3400                 :             : /* Mark REG as having no known equivalence.
    3401                 :             :    Some instructions might have been processed before and furnished
    3402                 :             :    with REG_EQUIV notes for this register; these notes will have to be
    3403                 :             :    removed.
    3404                 :             :    STORE is the piece of RTL that does the non-constant / conflicting
    3405                 :             :    assignment - a SET, CLOBBER or REG_INC note.  It is currently not used,
    3406                 :             :    but needs to be there because this function is called from note_stores.  */
    3407                 :             : static void
    3408                 :    47473048 : no_equiv (rtx reg, const_rtx store ATTRIBUTE_UNUSED,
    3409                 :             :           void *data ATTRIBUTE_UNUSED)
    3410                 :             : {
    3411                 :    47473048 :   int regno;
    3412                 :    47473048 :   rtx_insn_list *list;
    3413                 :             : 
    3414                 :    47473048 :   if (!REG_P (reg))
    3415                 :             :     return;
    3416                 :    33116199 :   regno = REGNO (reg);
    3417                 :    33116199 :   reg_equiv[regno].no_equiv = 1;
    3418                 :    33116199 :   list = reg_equiv[regno].init_insns;
    3419                 :    60152420 :   if (list && list->insn () == NULL)
    3420                 :             :     return;
    3421                 :     6827328 :   reg_equiv[regno].init_insns = gen_rtx_INSN_LIST (VOIDmode, NULL_RTX, NULL);
    3422                 :     6827328 :   reg_equiv[regno].replacement = NULL_RTX;
    3423                 :             :   /* This doesn't matter for equivalences made for argument registers, we
    3424                 :             :      should keep their initialization insns.  */
    3425                 :     6827328 :   if (reg_equiv[regno].is_arg_equivalence)
    3426                 :             :     return;
    3427                 :     6822964 :   ira_reg_equiv[regno].defined_p = false;
    3428                 :     6822964 :   ira_reg_equiv[regno].caller_save_p = false;
    3429                 :     6822964 :   ira_reg_equiv[regno].init_insns = NULL;
    3430                 :     7626955 :   for (; list; list = list->next ())
    3431                 :             :     {
    3432                 :      803991 :       rtx_insn *insn = list->insn ();
    3433                 :      803991 :       remove_note (insn, find_reg_note (insn, REG_EQUIV, NULL_RTX));
    3434                 :             :     }
    3435                 :             : }
    3436                 :             : 
    3437                 :             : /* Check whether the SUBREG is a paradoxical subreg and set the result
    3438                 :             :    in PDX_SUBREGS.  */
    3439                 :             : 
    3440                 :             : static void
    3441                 :    78357574 : set_paradoxical_subreg (rtx_insn *insn)
    3442                 :             : {
    3443                 :    78357574 :   subrtx_iterator::array_type array;
    3444                 :   494749150 :   FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
    3445                 :             :     {
    3446                 :   416391576 :       const_rtx subreg = *iter;
    3447                 :   416391576 :       if (GET_CODE (subreg) == SUBREG)
    3448                 :             :         {
    3449                 :     2812256 :           const_rtx reg = SUBREG_REG (subreg);
    3450                 :     2812256 :           if (REG_P (reg) && paradoxical_subreg_p (subreg))
    3451                 :      835084 :             reg_equiv[REGNO (reg)].pdx_subregs = true;
    3452                 :             :         }
    3453                 :             :     }
    3454                 :    78357574 : }
    3455                 :             : 
    3456                 :             : /* In DEBUG_INSN location adjust REGs from CLEARED_REGS bitmap to the
    3457                 :             :    equivalent replacement.  */
    3458                 :             : 
    3459                 :             : static rtx
    3460                 :    29565967 : adjust_cleared_regs (rtx loc, const_rtx old_rtx ATTRIBUTE_UNUSED, void *data)
    3461                 :             : {
    3462                 :    29565967 :   if (REG_P (loc))
    3463                 :             :     {
    3464                 :     4693930 :       bitmap cleared_regs = (bitmap) data;
    3465                 :     4693930 :       if (bitmap_bit_p (cleared_regs, REGNO (loc)))
    3466                 :       27462 :         return simplify_replace_fn_rtx (copy_rtx (*reg_equiv[REGNO (loc)].src_p),
    3467                 :       27462 :                                         NULL_RTX, adjust_cleared_regs, data);
    3468                 :             :     }
    3469                 :             :   return NULL_RTX;
    3470                 :             : }
    3471                 :             : 
    3472                 :             : /* Given register REGNO is set only once, return true if the defining
    3473                 :             :    insn dominates all uses.  */
    3474                 :             : 
    3475                 :             : static bool
    3476                 :       48173 : def_dominates_uses (int regno)
    3477                 :             : {
    3478                 :       48173 :   df_ref def = DF_REG_DEF_CHAIN (regno);
    3479                 :             : 
    3480                 :       48173 :   struct df_insn_info *def_info = DF_REF_INSN_INFO (def);
    3481                 :             :   /* If this is an artificial def (eh handler regs, hard frame pointer
    3482                 :             :      for non-local goto, regs defined on function entry) then def_info
    3483                 :             :      is NULL and the reg is always live before any use.  We might
    3484                 :             :      reasonably return true in that case, but since the only call
    3485                 :             :      of this function is currently here in ira.cc when we are looking
    3486                 :             :      at a defining insn we can't have an artificial def as that would
    3487                 :             :      bump DF_REG_DEF_COUNT.  */
    3488                 :       48173 :   gcc_assert (DF_REG_DEF_COUNT (regno) == 1 && def_info != NULL);
    3489                 :             : 
    3490                 :       48173 :   rtx_insn *def_insn = DF_REF_INSN (def);
    3491                 :       48173 :   basic_block def_bb = BLOCK_FOR_INSN (def_insn);
    3492                 :             : 
    3493                 :       48173 :   for (df_ref use = DF_REG_USE_CHAIN (regno);
    3494                 :      138085 :        use;
    3495                 :       89912 :        use = DF_REF_NEXT_REG (use))
    3496                 :             :     {
    3497                 :       89913 :       struct df_insn_info *use_info = DF_REF_INSN_INFO (use);
    3498                 :             :       /* Only check real uses, not artificial ones.  */
    3499                 :       89913 :       if (use_info)
    3500                 :             :         {
    3501                 :       89913 :           rtx_insn *use_insn = DF_REF_INSN (use);
    3502                 :       89913 :           if (!DEBUG_INSN_P (use_insn))
    3503                 :             :             {
    3504                 :       89661 :               basic_block use_bb = BLOCK_FOR_INSN (use_insn);
    3505                 :       89661 :               if (use_bb != def_bb
    3506                 :       89661 :                   ? !dominated_by_p (CDI_DOMINATORS, use_bb, def_bb)
    3507                 :       53036 :                   : DF_INSN_INFO_LUID (use_info) < DF_INSN_INFO_LUID (def_info))
    3508                 :             :                 return false;
    3509                 :             :             }
    3510                 :             :         }
    3511                 :             :     }
    3512                 :             :   return true;
    3513                 :             : }
    3514                 :             : 
    3515                 :             : /* Scan the instructions before update_equiv_regs.  Record which registers
    3516                 :             :    are referenced as paradoxical subregs.  Also check for cases in which
    3517                 :             :    the current function needs to save a register that one of its call
    3518                 :             :    instructions clobbers.
    3519                 :             : 
    3520                 :             :    These things are logically unrelated, but it's more efficient to do
    3521                 :             :    them together.  */
    3522                 :             : 
    3523                 :             : static void
    3524                 :     1421530 : update_equiv_regs_prescan (void)
    3525                 :             : {
    3526                 :     1421530 :   basic_block bb;
    3527                 :     1421530 :   rtx_insn *insn;
    3528                 :     1421530 :   function_abi_aggregator callee_abis;
    3529                 :             : 
    3530                 :    14657190 :   FOR_EACH_BB_FN (bb, cfun)
    3531                 :   155197061 :     FOR_BB_INSNS (bb, insn)
    3532                 :   141961401 :       if (NONDEBUG_INSN_P (insn))
    3533                 :             :         {
    3534                 :    78357574 :           set_paradoxical_subreg (insn);
    3535                 :    78357574 :           if (CALL_P (insn))
    3536                 :     5731093 :             callee_abis.note_callee_abi (insn_callee_abi (insn));
    3537                 :             :         }
    3538                 :             : 
    3539                 :     1421530 :   HARD_REG_SET extra_caller_saves = callee_abis.caller_save_regs (*crtl->abi);
    3540                 :     2843060 :   if (!hard_reg_set_empty_p (extra_caller_saves))
    3541                 :           0 :     for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
    3542                 :           0 :       if (TEST_HARD_REG_BIT (extra_caller_saves, regno))
    3543                 :           0 :         df_set_regs_ever_live (regno, true);
    3544                 :     1421530 : }
    3545                 :             : 
    3546                 :             : /* Find registers that are equivalent to a single value throughout the
    3547                 :             :    compilation (either because they can be referenced in memory or are
    3548                 :             :    set once from a single constant).  Lower their priority for a
    3549                 :             :    register.
    3550                 :             : 
    3551                 :             :    If such a register is only referenced once, try substituting its
    3552                 :             :    value into the using insn.  If it succeeds, we can eliminate the
    3553                 :             :    register completely.
    3554                 :             : 
    3555                 :             :    Initialize init_insns in ira_reg_equiv array.  */
    3556                 :             : static void
    3557                 :     1421530 : update_equiv_regs (void)
    3558                 :             : {
    3559                 :     1421530 :   rtx_insn *insn;
    3560                 :     1421530 :   basic_block bb;
    3561                 :             : 
    3562                 :             :   /* Scan the insns and find which registers have equivalences.  Do this
    3563                 :             :      in a separate scan of the insns because (due to -fcse-follow-jumps)
    3564                 :             :      a register can be set below its use.  */
    3565                 :     1421530 :   bitmap setjmp_crosses = regstat_get_setjmp_crosses ();
    3566                 :    14657190 :   FOR_EACH_BB_FN (bb, cfun)
    3567                 :             :     {
    3568                 :    13235660 :       int loop_depth = bb_loop_depth (bb);
    3569                 :             : 
    3570                 :   155197061 :       for (insn = BB_HEAD (bb);
    3571                 :   155197061 :            insn != NEXT_INSN (BB_END (bb));
    3572                 :   141961401 :            insn = NEXT_INSN (insn))
    3573                 :             :         {
    3574                 :   141961401 :           rtx note;
    3575                 :   141961401 :           rtx set;
    3576                 :   141961401 :           rtx dest, src;
    3577                 :   141961401 :           int regno;
    3578                 :             : 
    3579                 :   141961401 :           if (! INSN_P (insn))
    3580                 :    24486842 :             continue;
    3581                 :             : 
    3582                 :   196411909 :           for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    3583                 :    78937350 :             if (REG_NOTE_KIND (note) == REG_INC)
    3584                 :           0 :               no_equiv (XEXP (note, 0), note, NULL);
    3585                 :             : 
    3586                 :   117474559 :           set = single_set (insn);
    3587                 :             : 
    3588                 :             :           /* If this insn contains more (or less) than a single SET,
    3589                 :             :              only mark all destinations as having no known equivalence.  */
    3590                 :   164585765 :           if (set == NULL_RTX
    3591                 :   117474559 :               || side_effects_p (SET_SRC (set)))
    3592                 :             :             {
    3593                 :    47111206 :               note_pattern_stores (PATTERN (insn), no_equiv, NULL);
    3594                 :    47111206 :               continue;
    3595                 :             :             }
    3596                 :    70363353 :           else if (GET_CODE (PATTERN (insn)) == PARALLEL)
    3597                 :             :             {
    3598                 :     9928263 :               int i;
    3599                 :             : 
    3600                 :    30047419 :               for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
    3601                 :             :                 {
    3602                 :    20119156 :                   rtx part = XVECEXP (PATTERN (insn), 0, i);
    3603                 :    20119156 :                   if (part != set)
    3604                 :    10190893 :                     note_pattern_stores (part, no_equiv, NULL);
    3605                 :             :                 }
    3606                 :             :             }
    3607                 :             : 
    3608                 :    70363353 :           dest = SET_DEST (set);
    3609                 :    70363353 :           src = SET_SRC (set);
    3610                 :             : 
    3611                 :             :           /* See if this is setting up the equivalence between an argument
    3612                 :             :              register and its stack slot.  */
    3613                 :    70363353 :           note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
    3614                 :    70363353 :           if (note)
    3615                 :             :             {
    3616                 :      225343 :               gcc_assert (REG_P (dest));
    3617                 :      225343 :               regno = REGNO (dest);
    3618                 :             : 
    3619                 :             :               /* Note that we don't want to clear init_insns in
    3620                 :             :                  ira_reg_equiv even if there are multiple sets of this
    3621                 :             :                  register.  */
    3622                 :      225343 :               reg_equiv[regno].is_arg_equivalence = 1;
    3623                 :             : 
    3624                 :             :               /* The insn result can have equivalence memory although
    3625                 :             :                  the equivalence is not set up by the insn.  We add
    3626                 :             :                  this insn to init insns as it is a flag for now that
    3627                 :             :                  regno has an equivalence.  We will remove the insn
    3628                 :             :                  from init insn list later.  */
    3629                 :      225343 :               if (rtx_equal_p (src, XEXP (note, 0)) || MEM_P (XEXP (note, 0)))
    3630                 :      225343 :                 ira_reg_equiv[regno].init_insns
    3631                 :      225343 :                   = gen_rtx_INSN_LIST (VOIDmode, insn,
    3632                 :      225343 :                                        ira_reg_equiv[regno].init_insns);
    3633                 :             : 
    3634                 :             :               /* Continue normally in case this is a candidate for
    3635                 :             :                  replacements.  */
    3636                 :             :             }
    3637                 :             : 
    3638                 :    70363353 :           if (!optimize)
    3639                 :    21748866 :             continue;
    3640                 :             : 
    3641                 :             :           /* We only handle the case of a pseudo register being set
    3642                 :             :              once, or always to the same value.  */
    3643                 :             :           /* ??? The mn10200 port breaks if we add equivalences for
    3644                 :             :              values that need an ADDRESS_REGS register and set them equivalent
    3645                 :             :              to a MEM of a pseudo.  The actual problem is in the over-conservative
    3646                 :             :              handling of INPADDR_ADDRESS / INPUT_ADDRESS / INPUT triples in
    3647                 :             :              calculate_needs, but we traditionally work around this problem
    3648                 :             :              here by rejecting equivalences when the destination is in a register
    3649                 :             :              that's likely spilled.  This is fragile, of course, since the
    3650                 :             :              preferred class of a pseudo depends on all instructions that set
    3651                 :             :              or use it.  */
    3652                 :             : 
    3653                 :    80354897 :           if (!REG_P (dest)
    3654                 :    33897247 :               || (regno = REGNO (dest)) < FIRST_PSEUDO_REGISTER
    3655                 :    19239446 :               || (reg_equiv[regno].init_insns
    3656                 :     3166118 :                   && reg_equiv[regno].init_insns->insn () == NULL)
    3657                 :    65488627 :               || (targetm.class_likely_spilled_p (reg_preferred_class (regno))
    3658                 :         420 :                   && MEM_P (src) && ! reg_equiv[regno].is_arg_equivalence))
    3659                 :             :             {
    3660                 :             :               /* This might be setting a SUBREG of a pseudo, a pseudo that is
    3661                 :             :                  also set somewhere else to a constant.  */
    3662                 :    31740410 :               note_pattern_stores (set, no_equiv, NULL);
    3663                 :    31740410 :               continue;
    3664                 :             :             }
    3665                 :             : 
    3666                 :             :           /* Don't set reg mentioned in a paradoxical subreg
    3667                 :             :              equivalent to a mem.  */
    3668                 :    16874077 :           if (MEM_P (src) && reg_equiv[regno].pdx_subregs)
    3669                 :             :             {
    3670                 :       16054 :               note_pattern_stores (set, no_equiv, NULL);
    3671                 :       16054 :               continue;
    3672                 :             :             }
    3673                 :             : 
    3674                 :    16858023 :           note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
    3675                 :             : 
    3676                 :             :           /* cse sometimes generates function invariants, but doesn't put a
    3677                 :             :              REG_EQUAL note on the insn.  Since this note would be redundant,
    3678                 :             :              there's no point creating it earlier than here.  */
    3679                 :    16858023 :           if (! note && ! rtx_varies_p (src, 0))
    3680                 :     2629287 :             note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (src));
    3681                 :             : 
    3682                 :             :           /* Don't bother considering a REG_EQUAL note containing an EXPR_LIST
    3683                 :             :              since it represents a function call.  */
    3684                 :    16858023 :           if (note && GET_CODE (XEXP (note, 0)) == EXPR_LIST)
    3685                 :    13281874 :             note = NULL_RTX;
    3686                 :             : 
    3687                 :    16858023 :           if (DF_REG_DEF_COUNT (regno) != 1)
    3688                 :             :             {
    3689                 :     2660319 :               bool equal_p = true;
    3690                 :     2660319 :               rtx_insn_list *list;
    3691                 :             : 
    3692                 :             :               /* If we have already processed this pseudo and determined it
    3693                 :             :                  cannot have an equivalence, then honor that decision.  */
    3694                 :     2660319 :               if (reg_equiv[regno].no_equiv)
    3695                 :           0 :                 continue;
    3696                 :             : 
    3697                 :     4249468 :               if (! note
    3698                 :     1100452 :                   || rtx_varies_p (XEXP (note, 0), 0)
    3699                 :     3731489 :                   || (reg_equiv[regno].replacement
    3700                 :           0 :                       && ! rtx_equal_p (XEXP (note, 0),
    3701                 :             :                                         reg_equiv[regno].replacement)))
    3702                 :             :                 {
    3703                 :     1589149 :                   no_equiv (dest, set, NULL);
    3704                 :     1589149 :                   continue;
    3705                 :             :                 }
    3706                 :             : 
    3707                 :     1071170 :               list = reg_equiv[regno].init_insns;
    3708                 :     2778433 :               for (; list; list = list->next ())
    3709                 :             :                 {
    3710                 :     1788449 :                   rtx note_tmp;
    3711                 :     1788449 :                   rtx_insn *insn_tmp;
    3712                 :             : 
    3713                 :     1788449 :                   insn_tmp = list->insn ();
    3714                 :     1788449 :                   note_tmp = find_reg_note (insn_tmp, REG_EQUAL, NULL_RTX);
    3715                 :     1788449 :                   gcc_assert (note_tmp);
    3716                 :     1788449 :                   if (! rtx_equal_p (XEXP (note, 0), XEXP (note_tmp, 0)))
    3717                 :             :                     {
    3718                 :             :                       equal_p = false;
    3719                 :             :                       break;
    3720                 :             :                     }
    3721                 :             :                 }
    3722                 :             : 
    3723                 :     1071170 :               if (! equal_p)
    3724                 :             :                 {
    3725                 :       81186 :                   no_equiv (dest, set, NULL);
    3726                 :       81186 :                   continue;
    3727                 :             :                 }
    3728                 :             :             }
    3729                 :             : 
    3730                 :             :           /* Record this insn as initializing this register.  */
    3731                 :    15187688 :           reg_equiv[regno].init_insns
    3732                 :    15187688 :             = gen_rtx_INSN_LIST (VOIDmode, insn, reg_equiv[regno].init_insns);
    3733                 :             : 
    3734                 :             :           /* If this register is known to be equal to a constant, record that
    3735                 :             :              it is always equivalent to the constant.
    3736                 :             :              Note that it is possible to have a register use before
    3737                 :             :              the def in loops (see gcc.c-torture/execute/pr79286.c)
    3738                 :             :              where the reg is undefined on first use.  If the def insn
    3739                 :             :              won't trap we can use it as an equivalence, effectively
    3740                 :             :              choosing the "undefined" value for the reg to be the
    3741                 :             :              same as the value set by the def.  */
    3742                 :    15187688 :           if (DF_REG_DEF_COUNT (regno) == 1
    3743                 :    14197704 :               && note
    3744                 :     2475697 :               && !rtx_varies_p (XEXP (note, 0), 0)
    3745                 :    17299305 :               && (!may_trap_or_fault_p (XEXP (note, 0))
    3746                 :       48173 :                   || def_dominates_uses (regno)))
    3747                 :             :             {
    3748                 :     2111616 :               rtx note_value = XEXP (note, 0);
    3749                 :     2111616 :               remove_note (insn, note);
    3750                 :     2111616 :               set_unique_reg_note (insn, REG_EQUIV, note_value);
    3751                 :             :             }
    3752                 :             : 
    3753                 :             :           /* If this insn introduces a "constant" register, decrease the priority
    3754                 :             :              of that register.  Record this insn if the register is only used once
    3755                 :             :              more and the equivalence value is the same as our source.
    3756                 :             : 
    3757                 :             :              The latter condition is checked for two reasons:  First, it is an
    3758                 :             :              indication that it may be more efficient to actually emit the insn
    3759                 :             :              as written (if no registers are available, reload will substitute
    3760                 :             :              the equivalence).  Secondly, it avoids problems with any registers
    3761                 :             :              dying in this insn whose death notes would be missed.
    3762                 :             : 
    3763                 :             :              If we don't have a REG_EQUIV note, see if this insn is loading
    3764                 :             :              a register used only in one basic block from a MEM.  If so, and the
    3765                 :             :              MEM remains unchanged for the life of the register, add a REG_EQUIV
    3766                 :             :              note.  */
    3767                 :    15187688 :           note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
    3768                 :             : 
    3769                 :    15187688 :           rtx replacement = NULL_RTX;
    3770                 :    15187688 :           if (note)
    3771                 :     2330485 :             replacement = XEXP (note, 0);
    3772                 :    12857203 :           else if (REG_BASIC_BLOCK (regno) >= NUM_FIXED_BLOCKS
    3773                 :     9276199 :                    && MEM_P (SET_SRC (set)))
    3774                 :             :             {
    3775                 :     2717935 :               enum valid_equiv validity;
    3776                 :     2717935 :               validity = validate_equiv_mem (insn, dest, SET_SRC (set));
    3777                 :     2717935 :               if (validity != valid_none)
    3778                 :             :                 {
    3779                 :     2030208 :                   replacement = copy_rtx (SET_SRC (set));
    3780                 :     2030208 :                   if (validity == valid_reload)
    3781                 :             :                     {
    3782                 :     2029417 :                       note = set_unique_reg_note (insn, REG_EQUIV, replacement);
    3783                 :             :                     }
    3784                 :         791 :                   else if (ira_use_lra_p)
    3785                 :             :                     {
    3786                 :             :                       /* We still can use this equivalence for caller save
    3787                 :             :                          optimization in LRA.  Mark this.  */
    3788                 :         791 :                       ira_reg_equiv[regno].caller_save_p = true;
    3789                 :         791 :                       ira_reg_equiv[regno].init_insns
    3790                 :         791 :                         = gen_rtx_INSN_LIST (VOIDmode, insn,
    3791                 :         791 :                                              ira_reg_equiv[regno].init_insns);
    3792                 :             :                     }
    3793                 :             :                 }
    3794                 :             :             }
    3795                 :             : 
    3796                 :             :           /* If we haven't done so, record for reload that this is an
    3797                 :             :              equivalencing insn.  */
    3798                 :    15187688 :           if (note && !reg_equiv[regno].is_arg_equivalence)
    3799                 :     4141033 :             ira_reg_equiv[regno].init_insns
    3800                 :     4141033 :               = gen_rtx_INSN_LIST (VOIDmode, insn,
    3801                 :     4141033 :                                    ira_reg_equiv[regno].init_insns);
    3802                 :             : 
    3803                 :    15187688 :           if (replacement)
    3804                 :             :             {
    3805                 :     4360693 :               reg_equiv[regno].replacement = replacement;
    3806                 :     4360693 :               reg_equiv[regno].src_p = &SET_SRC (set);
    3807                 :     4360693 :               reg_equiv[regno].loop_depth = (short) loop_depth;
    3808                 :             : 
    3809                 :             :               /* Don't mess with things live during setjmp.  */
    3810                 :     4360693 :               if (optimize && !bitmap_bit_p (setjmp_crosses, regno))
    3811                 :             :                 {
    3812                 :             :                   /* If the register is referenced exactly twice, meaning it is
    3813                 :             :                      set once and used once, indicate that the reference may be
    3814                 :             :                      replaced by the equivalence we computed above.  Do this
    3815                 :             :                      even if the register is only used in one block so that
    3816                 :             :                      dependencies can be handled where the last register is
    3817                 :             :                      used in a different block (i.e. HIGH / LO_SUM sequences)
    3818                 :             :                      and to reduce the number of registers alive across
    3819                 :             :                      calls.  */
    3820                 :             : 
    3821                 :     4360652 :                   if (REG_N_REFS (regno) == 2
    3822                 :     3439943 :                       && (rtx_equal_p (replacement, src)
    3823                 :      374827 :                           || ! equiv_init_varies_p (src))
    3824                 :     3407652 :                       && NONJUMP_INSN_P (insn)
    3825                 :     7768304 :                       && equiv_init_movable_p (PATTERN (insn), regno))
    3826                 :     2117609 :                     reg_equiv[regno].replace = 1;
    3827                 :             :                 }
    3828                 :             :             }
    3829                 :             :         }
    3830                 :             :     }
    3831                 :     1421530 : }
    3832                 :             : 
    3833                 :             : /* For insns that set a MEM to the contents of a REG that is only used
    3834                 :             :    in a single basic block, see if the register is always equivalent
    3835                 :             :    to that memory location and if moving the store from INSN to the
    3836                 :             :    insn that sets REG is safe.  If so, put a REG_EQUIV note on the
    3837                 :             :    initializing insn.  */
    3838                 :             : static void
    3839                 :      922992 : add_store_equivs (void)
    3840                 :             : {
    3841                 :      922992 :   auto_sbitmap seen_insns (get_max_uid () + 1);
    3842                 :      922992 :   bitmap_clear (seen_insns);
    3843                 :             : 
    3844                 :   112671517 :   for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn))
    3845                 :             :     {
    3846                 :   111748525 :       rtx set, src, dest;
    3847                 :   111748525 :       unsigned regno;
    3848                 :   111748525 :       rtx_insn *init_insn;
    3849                 :             : 
    3850                 :   111748525 :       bitmap_set_bit (seen_insns, INSN_UID (insn));
    3851                 :             : 
    3852                 :   111748525 :       if (! INSN_P (insn))
    3853                 :    21890095 :         continue;
    3854                 :             : 
    3855                 :    89858430 :       set = single_set (insn);
    3856                 :    89858430 :       if (! set)
    3857                 :    42466757 :         continue;
    3858                 :             : 
    3859                 :    47391673 :       dest = SET_DEST (set);
    3860                 :    47391673 :       src = SET_SRC (set);
    3861                 :             : 
    3862                 :             :       /* Don't add a REG_EQUIV note if the insn already has one.  The existing
    3863                 :             :          REG_EQUIV is likely more useful than the one we are adding.  */
    3864                 :    52067443 :       if (MEM_P (dest) && REG_P (src)
    3865                 :     4675770 :           && (regno = REGNO (src)) >= FIRST_PSEUDO_REGISTER
    3866                 :     4612369 :           && REG_BASIC_BLOCK (regno) >= NUM_FIXED_BLOCKS
    3867                 :     2709259 :           && DF_REG_DEF_COUNT (regno) == 1
    3868                 :     2642362 :           && ! reg_equiv[regno].pdx_subregs
    3869                 :     2497019 :           && reg_equiv[regno].init_insns != NULL
    3870                 :     2497019 :           && (init_insn = reg_equiv[regno].init_insns->insn ()) != 0
    3871                 :     2478318 :           && bitmap_bit_p (seen_insns, INSN_UID (init_insn))
    3872                 :     2478318 :           && ! find_reg_note (init_insn, REG_EQUIV, NULL_RTX)
    3873                 :      847169 :           && validate_equiv_mem (init_insn, src, dest) == valid_reload
    3874                 :      493378 :           && ! memref_used_between_p (dest, init_insn, insn)
    3875                 :             :           /* Attaching a REG_EQUIV note will fail if INIT_INSN has
    3876                 :             :              multiple sets.  */
    3877                 :    47813861 :           && set_unique_reg_note (init_insn, REG_EQUIV, copy_rtx (dest)))
    3878                 :             :         {
    3879                 :             :           /* This insn makes the equivalence, not the one initializing
    3880                 :             :              the register.  */
    3881                 :      421804 :           ira_reg_equiv[regno].init_insns
    3882                 :      421804 :             = gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX);
    3883                 :      421804 :           df_notes_rescan (init_insn);
    3884                 :      421804 :           if (dump_file)
    3885                 :          88 :             fprintf (dump_file,
    3886                 :             :                      "Adding REG_EQUIV to insn %d for source of insn %d\n",
    3887                 :          88 :                      INSN_UID (init_insn),
    3888                 :          88 :                      INSN_UID (insn));
    3889                 :             :         }
    3890                 :             :     }
    3891                 :      922992 : }
    3892                 :             : 
    3893                 :             : /* Scan all regs killed in an insn to see if any of them are registers
    3894                 :             :    only used that once.  If so, see if we can replace the reference
    3895                 :             :    with the equivalent form.  If we can, delete the initializing
    3896                 :             :    reference and this register will go away.  If we can't replace the
    3897                 :             :    reference, and the initializing reference is within the same loop
    3898                 :             :    (or in an inner loop), then move the register initialization just
    3899                 :             :    before the use, so that they are in the same basic block.  */
    3900                 :             : static void
    3901                 :      996408 : combine_and_move_insns (void)
    3902                 :             : {
    3903                 :      996408 :   auto_bitmap cleared_regs;
    3904                 :      996408 :   int max = max_reg_num ();
    3905                 :             : 
    3906                 :    48159439 :   for (int regno = FIRST_PSEUDO_REGISTER; regno < max; regno++)
    3907                 :             :     {
    3908                 :    47163031 :       if (!reg_equiv[regno].replace)
    3909                 :    45045636 :         continue;
    3910                 :             : 
    3911                 :     2117395 :       rtx_insn *use_insn = 0;
    3912                 :     2117395 :       for (df_ref use = DF_REG_USE_CHAIN (regno);
    3913                 :     4264772 :            use;
    3914                 :     2147377 :            use = DF_REF_NEXT_REG (use))
    3915                 :     2147377 :         if (DF_REF_INSN_INFO (use))
    3916                 :             :           {
    3917                 :     2147377 :             if (DEBUG_INSN_P (DF_REF_INSN (use)))
    3918                 :       29982 :               continue;
    3919                 :     2117395 :             gcc_assert (!use_insn);
    3920                 :             :             use_insn = DF_REF_INSN (use);
    3921                 :             :           }
    3922                 :     2117395 :       gcc_assert (use_insn);
    3923                 :             : 
    3924                 :             :       /* Don't substitute into jumps.  indirect_jump_optimize does
    3925                 :             :          this for anything we are prepared to handle.  */
    3926                 :     2117395 :       if (JUMP_P (use_insn))
    3927                 :         385 :         continue;
    3928                 :             : 
    3929                 :             :       /* Also don't substitute into a conditional trap insn -- it can become
    3930                 :             :          an unconditional trap, and that is a flow control insn.  */
    3931                 :     2117010 :       if (GET_CODE (PATTERN (use_insn)) == TRAP_IF)
    3932                 :           0 :         continue;
    3933                 :             : 
    3934                 :     2117010 :       df_ref def = DF_REG_DEF_CHAIN (regno);
    3935                 :     2117010 :       gcc_assert (DF_REG_DEF_COUNT (regno) == 1 && DF_REF_INSN_INFO (def));
    3936                 :     2117010 :       rtx_insn *def_insn = DF_REF_INSN (def);
    3937                 :             : 
    3938                 :             :       /* We may not move instructions that can throw, since that
    3939                 :             :          changes basic block boundaries and we are not prepared to
    3940                 :             :          adjust the CFG to match.  */
    3941                 :     2117010 :       if (can_throw_internal (def_insn))
    3942                 :           0 :         continue;
    3943                 :             : 
    3944                 :             :       /* Instructions with multiple sets can only be moved if DF analysis is
    3945                 :             :          performed for all of the registers set.  See PR91052.  */
    3946                 :     2117010 :       if (multiple_sets (def_insn))
    3947                 :           0 :         continue;
    3948                 :             : 
    3949                 :     2117010 :       basic_block use_bb = BLOCK_FOR_INSN (use_insn);
    3950                 :     2117010 :       basic_block def_bb = BLOCK_FOR_INSN (def_insn);
    3951                 :     2117010 :       if (bb_loop_depth (use_bb) > bb_loop_depth (def_bb))
    3952                 :      130943 :         continue;
    3953                 :             : 
    3954                 :     1986067 :       if (asm_noperands (PATTERN (def_insn)) < 0
    3955                 :     3972134 :           && validate_replace_rtx (regno_reg_rtx[regno],
    3956                 :     1986067 :                                    *reg_equiv[regno].src_p, use_insn))
    3957                 :             :         {
    3958                 :      340151 :           rtx link;
    3959                 :             :           /* Append the REG_DEAD notes from def_insn.  */
    3960                 :      681181 :           for (rtx *p = &REG_NOTES (def_insn); (link = *p) != 0; )
    3961                 :             :             {
    3962                 :      341030 :               if (REG_NOTE_KIND (XEXP (link, 0)) == REG_DEAD)
    3963                 :             :                 {
    3964                 :           0 :                   *p = XEXP (link, 1);
    3965                 :           0 :                   XEXP (link, 1) = REG_NOTES (use_insn);
    3966                 :           0 :                   REG_NOTES (use_insn) = link;
    3967                 :             :                 }
    3968                 :             :               else
    3969                 :      341030 :                 p = &XEXP (link, 1);
    3970                 :             :             }
    3971                 :             : 
    3972                 :      340151 :           remove_death (regno, use_insn);
    3973                 :      340151 :           SET_REG_N_REFS (regno, 0);
    3974                 :      340151 :           REG_FREQ (regno) = 0;
    3975                 :      340151 :           df_ref use;
    3976                 :      401697 :           FOR_EACH_INSN_USE (use, def_insn)
    3977                 :             :             {
    3978                 :       61546 :               unsigned int use_regno = DF_REF_REGNO (use);
    3979                 :       61546 :               if (!HARD_REGISTER_NUM_P (use_regno))
    3980                 :        1253 :                 reg_equiv[use_regno].replace = 0;
    3981                 :             :             }
    3982                 :             : 
    3983                 :      340151 :           delete_insn (def_insn);
    3984                 :             : 
    3985                 :      340151 :           reg_equiv[regno].init_insns = NULL;
    3986                 :      340151 :           ira_reg_equiv[regno].init_insns = NULL;
    3987                 :      340151 :           bitmap_set_bit (cleared_regs, regno);
    3988                 :             :         }
    3989                 :             : 
    3990                 :             :       /* Move the initialization of the register to just before
    3991                 :             :          USE_INSN.  Update the flow information.  */
    3992                 :     1645916 :       else if (prev_nondebug_insn (use_insn) != def_insn)
    3993                 :             :         {
    3994                 :      304647 :           rtx_insn *new_insn;
    3995                 :             : 
    3996                 :      304647 :           new_insn = emit_insn_before (PATTERN (def_insn), use_insn);
    3997                 :      304647 :           REG_NOTES (new_insn) = REG_NOTES (def_insn);
    3998                 :      304647 :           REG_NOTES (def_insn) = 0;
    3999                 :             :           /* Rescan it to process the notes.  */
    4000                 :      304647 :           df_insn_rescan (new_insn);
    4001                 :             : 
    4002                 :             :           /* Make sure this insn is recognized before reload begins,
    4003                 :             :              otherwise eliminate_regs_in_insn will die.  */
    4004                 :      304647 :           INSN_CODE (new_insn) = INSN_CODE (def_insn);
    4005                 :             : 
    4006                 :      304647 :           delete_insn (def_insn);
    4007                 :             : 
    4008                 :      304647 :           XEXP (reg_equiv[regno].init_insns, 0) = new_insn;
    4009                 :             : 
    4010                 :      304647 :           REG_BASIC_BLOCK (regno) = use_bb->index;
    4011                 :      304647 :           REG_N_CALLS_CROSSED (regno) = 0;
    4012                 :             : 
    4013                 :      304647 :           if (use_insn == BB_HEAD (use_bb))
    4014                 :           0 :             BB_HEAD (use_bb) = new_insn;
    4015                 :             : 
    4016                 :             :           /* We know regno dies in use_insn, but inside a loop
    4017                 :             :              REG_DEAD notes might be missing when def_insn was in
    4018                 :             :              another basic block.  However, when we move def_insn into
    4019                 :             :              this bb we'll definitely get a REG_DEAD note and reload
    4020                 :             :              will see the death.  It's possible that update_equiv_regs
    4021                 :             :              set up an equivalence referencing regno for a reg set by
    4022                 :             :              use_insn, when regno was seen as non-local.  Now that
    4023                 :             :              regno is local to this block, and dies, such an
    4024                 :             :              equivalence is invalid.  */
    4025                 :      304647 :           if (find_reg_note (use_insn, REG_EQUIV, regno_reg_rtx[regno]))
    4026                 :             :             {
    4027                 :           0 :               rtx set = single_set (use_insn);
    4028                 :           0 :               if (set && REG_P (SET_DEST (set)))
    4029                 :           0 :                 no_equiv (SET_DEST (set), set, NULL);
    4030                 :             :             }
    4031                 :             : 
    4032                 :      304647 :           ira_reg_equiv[regno].init_insns
    4033                 :      304647 :             = gen_rtx_INSN_LIST (VOIDmode, new_insn, NULL_RTX);
    4034                 :      304647 :           bitmap_set_bit (cleared_regs, regno);
    4035                 :             :         }
    4036                 :             :     }
    4037                 :             : 
    4038                 :      996408 :   if (!bitmap_empty_p (cleared_regs))
    4039                 :             :     {
    4040                 :      210356 :       basic_block bb;
    4041                 :             : 
    4042                 :     5098413 :       FOR_EACH_BB_FN (bb, cfun)
    4043                 :             :         {
    4044                 :     9776114 :           bitmap_and_compl_into (DF_LR_IN (bb), cleared_regs);
    4045                 :     9776114 :           bitmap_and_compl_into (DF_LR_OUT (bb), cleared_regs);
    4046                 :     4888057 :           if (!df_live)
    4047                 :     4888057 :             continue;
    4048                 :           0 :           bitmap_and_compl_into (DF_LIVE_IN (bb), cleared_regs);
    4049                 :           0 :           bitmap_and_compl_into (DF_LIVE_OUT (bb), cleared_regs);
    4050                 :             :         }
    4051                 :             : 
    4052                 :             :       /* Last pass - adjust debug insns referencing cleared regs.  */
    4053                 :      210356 :       if (MAY_HAVE_DEBUG_BIND_INSNS)
    4054                 :    49814053 :         for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn))
    4055                 :    49697876 :           if (DEBUG_BIND_INSN_P (insn))
    4056                 :             :             {
    4057                 :    16208698 :               rtx old_loc = INSN_VAR_LOCATION_LOC (insn);
    4058                 :    16208698 :               INSN_VAR_LOCATION_LOC (insn)
    4059                 :    32417396 :                 = simplify_replace_fn_rtx (old_loc, NULL_RTX,
    4060                 :             :                                            adjust_cleared_regs,
    4061                 :    16208698 :                                            (void *) cleared_regs);
    4062                 :    16208698 :               if (old_loc != INSN_VAR_LOCATION_LOC (insn))
    4063                 :       27195 :                 df_insn_rescan (insn);
    4064                 :             :             }
    4065                 :             :     }
    4066                 :      996408 : }
    4067                 :             : 
    4068                 :             : /* A pass over indirect jumps, converting simple cases to direct jumps.
    4069                 :             :    Combine does this optimization too, but only within a basic block.  */
    4070                 :             : static void
    4071                 :     1421530 : indirect_jump_optimize (void)
    4072                 :             : {
    4073                 :     1421530 :   basic_block bb;
    4074                 :     1421530 :   bool rebuild_p = false;
    4075                 :             : 
    4076                 :    14657192 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    4077                 :             :     {
    4078                 :    13235662 :       rtx_insn *insn = BB_END (bb);
    4079                 :    18566778 :       if (!JUMP_P (insn)
    4080                 :    13235662 :           || find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
    4081                 :     5331116 :         continue;
    4082                 :             : 
    4083                 :     7904546 :       rtx x = pc_set (insn);
    4084                 :     7904546 :       if (!x || !REG_P (SET_SRC (x)))
    4085                 :     7893108 :         continue;
    4086                 :             : 
    4087                 :       11438 :       int regno = REGNO (SET_SRC (x));
    4088                 :       11438 :       if (DF_REG_DEF_COUNT (regno) == 1)
    4089                 :             :         {
    4090                 :       11327 :           df_ref def = DF_REG_DEF_CHAIN (regno);
    4091                 :       11327 :           if (!DF_REF_IS_ARTIFICIAL (def))
    4092                 :             :             {
    4093                 :       11327 :               rtx_insn *def_insn = DF_REF_INSN (def);
    4094                 :       11327 :               rtx lab = NULL_RTX;
    4095                 :       11327 :               rtx set = single_set (def_insn);
    4096                 :       11327 :               if (set && GET_CODE (SET_SRC (set)) == LABEL_REF)
    4097                 :             :                 lab = SET_SRC (set);
    4098                 :             :               else
    4099                 :             :                 {
    4100                 :       11326 :                   rtx eqnote = find_reg_note (def_insn, REG_EQUAL, NULL_RTX);
    4101                 :       11326 :                   if (eqnote && GET_CODE (XEXP (eqnote, 0)) == LABEL_REF)
    4102                 :             :                     lab = XEXP (eqnote, 0);
    4103                 :             :                 }
    4104                 :           1 :               if (lab && validate_replace_rtx (SET_SRC (x), lab, insn))
    4105                 :             :                 rebuild_p = true;
    4106                 :             :             }
    4107                 :             :         }
    4108                 :             :     }
    4109                 :             : 
    4110                 :     1421530 :   if (rebuild_p)
    4111                 :             :     {
    4112                 :           1 :       timevar_push (TV_JUMP);
    4113                 :           1 :       rebuild_jump_labels (get_insns ());
    4114                 :           1 :       if (purge_all_dead_edges ())
    4115                 :           1 :         delete_unreachable_blocks ();
    4116                 :           1 :       timevar_pop (TV_JUMP);
    4117                 :             :     }
    4118                 :     1421530 : }
    4119                 :             : 
    4120                 :             : /* Set up fields memory, constant, and invariant from init_insns in
    4121                 :             :    the structures of array ira_reg_equiv.  */
    4122                 :             : static void
    4123                 :     1421530 : setup_reg_equiv (void)
    4124                 :             : {
    4125                 :     1421530 :   int i;
    4126                 :     1421530 :   rtx_insn_list *elem, *prev_elem, *next_elem;
    4127                 :     1421530 :   rtx_insn *insn;
    4128                 :     1421530 :   rtx set, x;
    4129                 :             : 
    4130                 :   160053341 :   for (i = FIRST_PSEUDO_REGISTER; i < ira_reg_equiv_len; i++)
    4131                 :   158631811 :     for (prev_elem = NULL, elem = ira_reg_equiv[i].init_insns;
    4132                 :   162864647 :          elem;
    4133                 :             :          prev_elem = elem, elem = next_elem)
    4134                 :             :       {
    4135                 :     4446550 :         next_elem = elem->next ();
    4136                 :     4446550 :         insn = elem->insn ();
    4137                 :     4446550 :         set = single_set (insn);
    4138                 :             :         
    4139                 :             :         /* Init insns can set up equivalence when the reg is a destination or
    4140                 :             :            a source (in this case the destination is memory).  */
    4141                 :     4446550 :         if (set != 0 && (REG_P (SET_DEST (set)) || REG_P (SET_SRC (set))))
    4142                 :             :           {
    4143                 :     4446550 :             if ((x = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != NULL)
    4144                 :             :               {
    4145                 :     4024021 :                 x = XEXP (x, 0);
    4146                 :     4024021 :                 if (REG_P (SET_DEST (set))
    4147                 :     4024021 :                     && REGNO (SET_DEST (set)) == (unsigned int) i
    4148                 :     8048042 :                     && ! rtx_equal_p (SET_SRC (set), x) && MEM_P (x))
    4149                 :             :                   {
    4150                 :             :                     /* This insn reporting the equivalence but
    4151                 :             :                        actually not setting it.  Remove it from the
    4152                 :             :                        list.  */
    4153                 :       30537 :                     if (prev_elem == NULL)
    4154                 :       30537 :                       ira_reg_equiv[i].init_insns = next_elem;
    4155                 :             :                     else
    4156                 :           0 :                       XEXP (prev_elem, 1) = next_elem;
    4157                 :             :                     elem = prev_elem;
    4158                 :             :                   }
    4159                 :             :               }
    4160                 :      422529 :             else if (REG_P (SET_DEST (set))
    4161                 :      422529 :                      && REGNO (SET_DEST (set)) == (unsigned int) i)
    4162                 :         725 :               x = SET_SRC (set);
    4163                 :             :             else
    4164                 :             :               {      
    4165                 :      421804 :                 gcc_assert (REG_P (SET_SRC (set))
    4166                 :             :                             && REGNO (SET_SRC (set)) == (unsigned int) i);
    4167                 :             :                 x = SET_DEST (set);
    4168                 :             :               }
    4169                 :     4446550 :             if (! function_invariant_p (x)
    4170                 :     1807385 :                 || ! flag_pic
    4171                 :             :                 /* A function invariant is often CONSTANT_P but may
    4172                 :             :                    include a register.  We promise to only pass
    4173                 :             :                    CONSTANT_P objects to LEGITIMATE_PIC_OPERAND_P.  */
    4174                 :     4662585 :                 || (CONSTANT_P (x) && LEGITIMATE_PIC_OPERAND_P (x)))
    4175                 :             :               {
    4176                 :             :                 /* It can happen that a REG_EQUIV note contains a MEM
    4177                 :             :                    that is not a legitimate memory operand.  As later
    4178                 :             :                    stages of reload assume that all addresses found in
    4179                 :             :                    the lra_regno_equiv_* arrays were originally
    4180                 :             :                    legitimate, we ignore such REG_EQUIV notes.  */
    4181                 :     4305631 :                 if (memory_operand (x, VOIDmode))
    4182                 :             :                   {
    4183                 :     2566839 :                     ira_reg_equiv[i].defined_p = !ira_reg_equiv[i].caller_save_p;
    4184                 :     2566839 :                     ira_reg_equiv[i].memory = x;
    4185                 :     2566839 :                     continue;
    4186                 :             :                   }
    4187                 :     1738792 :                 else if (function_invariant_p (x))
    4188                 :             :                   {
    4189                 :     1666466 :                     machine_mode mode;
    4190                 :             :                     
    4191                 :     1666466 :                     mode = GET_MODE (SET_DEST (set));
    4192                 :     1666466 :                     if (GET_CODE (x) == PLUS
    4193                 :      932004 :                         || x == frame_pointer_rtx || x == arg_pointer_rtx)
    4194                 :             :                       /* This is PLUS of frame pointer and a constant,
    4195                 :             :                          or fp, or argp.  */
    4196                 :      735274 :                       ira_reg_equiv[i].invariant = x;
    4197                 :      931192 :                     else if (targetm.legitimate_constant_p (mode, x))
    4198                 :      693259 :                       ira_reg_equiv[i].constant = x;
    4199                 :             :                     else
    4200                 :             :                       {
    4201                 :      237933 :                         ira_reg_equiv[i].memory = force_const_mem (mode, x);
    4202                 :      237933 :                         if (ira_reg_equiv[i].memory == NULL_RTX)
    4203                 :             :                           {
    4204                 :         469 :                             ira_reg_equiv[i].defined_p = false;
    4205                 :         469 :                             ira_reg_equiv[i].caller_save_p = false;
    4206                 :         469 :                             ira_reg_equiv[i].init_insns = NULL;
    4207                 :         469 :                             break;
    4208                 :             :                           }
    4209                 :             :                       }
    4210                 :     1665997 :                     ira_reg_equiv[i].defined_p = true;
    4211                 :     1665997 :                     continue;
    4212                 :     1665997 :                   }
    4213                 :             :               }
    4214                 :             :           }
    4215                 :      213245 :         ira_reg_equiv[i].defined_p = false;
    4216                 :      213245 :         ira_reg_equiv[i].caller_save_p = false;
    4217                 :      213245 :         ira_reg_equiv[i].init_insns = NULL;
    4218                 :      213245 :         break;
    4219                 :             :       }
    4220                 :     1421530 : }
    4221                 :             : 
    4222                 :             : 
    4223                 :             : 
    4224                 :             : /* Print chain C to FILE.  */
    4225                 :             : static void
    4226                 :           0 : print_insn_chain (FILE *file, class insn_chain *c)
    4227                 :             : {
    4228                 :           0 :   fprintf (file, "insn=%d, ", INSN_UID (c->insn));
    4229                 :           0 :   bitmap_print (file, &c->live_throughout, "live_throughout: ", ", ");
    4230                 :           0 :   bitmap_print (file, &c->dead_or_set, "dead_or_set: ", "\n");
    4231                 :           0 : }
    4232                 :             : 
    4233                 :             : 
    4234                 :             : /* Print all reload_insn_chains to FILE.  */
    4235                 :             : static void
    4236                 :           0 : print_insn_chains (FILE *file)
    4237                 :             : {
    4238                 :           0 :   class insn_chain *c;
    4239                 :           0 :   for (c = reload_insn_chain; c ; c = c->next)
    4240                 :           0 :     print_insn_chain (file, c);
    4241                 :           0 : }
    4242                 :             : 
    4243                 :             : /* Return true if pseudo REGNO should be added to set live_throughout
    4244                 :             :    or dead_or_set of the insn chains for reload consideration.  */
    4245                 :             : static bool
    4246                 :           0 : pseudo_for_reload_consideration_p (int regno)
    4247                 :             : {
    4248                 :             :   /* Consider spilled pseudos too for IRA because they still have a
    4249                 :             :      chance to get hard-registers in the reload when IRA is used.  */
    4250                 :           0 :   return (reg_renumber[regno] >= 0 || ira_conflicts_p);
    4251                 :             : }
    4252                 :             : 
    4253                 :             : /* Return true if we can track the individual bytes of subreg X.
    4254                 :             :    When returning true, set *OUTER_SIZE to the number of bytes in
    4255                 :             :    X itself, *INNER_SIZE to the number of bytes in the inner register
    4256                 :             :    and *START to the offset of the first byte.  */
    4257                 :             : static bool
    4258                 :           0 : get_subreg_tracking_sizes (rtx x, HOST_WIDE_INT *outer_size,
    4259                 :             :                            HOST_WIDE_INT *inner_size, HOST_WIDE_INT *start)
    4260                 :             : {
    4261                 :           0 :   rtx reg = regno_reg_rtx[REGNO (SUBREG_REG (x))];
    4262                 :           0 :   return (GET_MODE_SIZE (GET_MODE (x)).is_constant (outer_size)
    4263                 :           0 :           && GET_MODE_SIZE (GET_MODE (reg)).is_constant (inner_size)
    4264                 :           0 :           && SUBREG_BYTE (x).is_constant (start));
    4265                 :             : }
    4266                 :             : 
    4267                 :             : /* Init LIVE_SUBREGS[ALLOCNUM] and LIVE_SUBREGS_USED[ALLOCNUM] for
    4268                 :             :    a register with SIZE bytes, making the register live if INIT_VALUE.  */
    4269                 :             : static void
    4270                 :           0 : init_live_subregs (bool init_value, sbitmap *live_subregs,
    4271                 :             :                    bitmap live_subregs_used, int allocnum, int size)
    4272                 :             : {
    4273                 :           0 :   gcc_assert (size > 0);
    4274                 :             : 
    4275                 :             :   /* Been there, done that.  */
    4276                 :           0 :   if (bitmap_bit_p (live_subregs_used, allocnum))
    4277                 :             :     return;
    4278                 :             : 
    4279                 :             :   /* Create a new one.  */
    4280                 :           0 :   if (live_subregs[allocnum] == NULL)
    4281                 :           0 :     live_subregs[allocnum] = sbitmap_alloc (size);
    4282                 :             : 
    4283                 :             :   /* If the entire reg was live before blasting into subregs, we need
    4284                 :             :      to init all of the subregs to ones else init to 0.  */
    4285                 :           0 :   if (init_value)
    4286                 :           0 :     bitmap_ones (live_subregs[allocnum]);
    4287                 :             :   else
    4288                 :           0 :     bitmap_clear (live_subregs[allocnum]);
    4289                 :             : 
    4290                 :           0 :   bitmap_set_bit (live_subregs_used, allocnum);
    4291                 :             : }
    4292                 :             : 
    4293                 :             : /* Walk the insns of the current function and build reload_insn_chain,
    4294                 :             :    and record register life information.  */
    4295                 :             : static void
    4296                 :           0 : build_insn_chain (void)
    4297                 :             : {
    4298                 :           0 :   unsigned int i;
    4299                 :           0 :   class insn_chain **p = &reload_insn_chain;
    4300                 :           0 :   basic_block bb;
    4301                 :           0 :   class insn_chain *c = NULL;
    4302                 :           0 :   class insn_chain *next = NULL;
    4303                 :           0 :   auto_bitmap live_relevant_regs;
    4304                 :           0 :   auto_bitmap elim_regset;
    4305                 :             :   /* live_subregs is a vector used to keep accurate information about
    4306                 :             :      which hardregs are live in multiword pseudos.  live_subregs and
    4307                 :             :      live_subregs_used are indexed by pseudo number.  The live_subreg
    4308                 :             :      entry for a particular pseudo is only used if the corresponding
    4309                 :             :      element is non zero in live_subregs_used.  The sbitmap size of
    4310                 :             :      live_subreg[allocno] is number of bytes that the pseudo can
    4311                 :             :      occupy.  */
    4312                 :           0 :   sbitmap *live_subregs = XCNEWVEC (sbitmap, max_regno);
    4313                 :           0 :   auto_bitmap live_subregs_used;
    4314                 :             : 
    4315                 :           0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    4316                 :           0 :     if (TEST_HARD_REG_BIT (eliminable_regset, i))
    4317                 :           0 :       bitmap_set_bit (elim_regset, i);
    4318                 :           0 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    4319                 :             :     {
    4320                 :           0 :       bitmap_iterator bi;
    4321                 :           0 :       rtx_insn *insn;
    4322                 :             : 
    4323                 :           0 :       CLEAR_REG_SET (live_relevant_regs);
    4324                 :           0 :       bitmap_clear (live_subregs_used);
    4325                 :             : 
    4326                 :           0 :       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb), 0, i, bi)
    4327                 :             :         {
    4328                 :           0 :           if (i >= FIRST_PSEUDO_REGISTER)
    4329                 :             :             break;
    4330                 :           0 :           bitmap_set_bit (live_relevant_regs, i);
    4331                 :             :         }
    4332                 :             : 
    4333                 :           0 :       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb),
    4334                 :             :                                 FIRST_PSEUDO_REGISTER, i, bi)
    4335                 :             :         {
    4336                 :           0 :           if (pseudo_for_reload_consideration_p (i))
    4337                 :           0 :             bitmap_set_bit (live_relevant_regs, i);
    4338                 :             :         }
    4339                 :             : 
    4340                 :           0 :       FOR_BB_INSNS_REVERSE (bb, insn)
    4341                 :             :         {
    4342                 :           0 :           if (!NOTE_P (insn) && !BARRIER_P (insn))
    4343                 :             :             {
    4344                 :           0 :               struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4345                 :           0 :               df_ref def, use;
    4346                 :             : 
    4347                 :           0 :               c = new_insn_chain ();
    4348                 :           0 :               c->next = next;
    4349                 :           0 :               next = c;
    4350                 :           0 :               *p = c;
    4351                 :           0 :               p = &c->prev;
    4352                 :             : 
    4353                 :           0 :               c->insn = insn;
    4354                 :           0 :               c->block = bb->index;
    4355                 :             : 
    4356                 :           0 :               if (NONDEBUG_INSN_P (insn))
    4357                 :           0 :                 FOR_EACH_INSN_INFO_DEF (def, insn_info)
    4358                 :             :                   {
    4359                 :           0 :                     unsigned int regno = DF_REF_REGNO (def);
    4360                 :             : 
    4361                 :             :                     /* Ignore may clobbers because these are generated
    4362                 :             :                        from calls. However, every other kind of def is
    4363                 :             :                        added to dead_or_set.  */
    4364                 :           0 :                     if (!DF_REF_FLAGS_IS_SET (def, DF_REF_MAY_CLOBBER))
    4365                 :             :                       {
    4366                 :           0 :                         if (regno < FIRST_PSEUDO_REGISTER)
    4367                 :             :                           {
    4368                 :           0 :                             if (!fixed_regs[regno])
    4369                 :           0 :                               bitmap_set_bit (&c->dead_or_set, regno);
    4370                 :             :                           }
    4371                 :           0 :                         else if (pseudo_for_reload_consideration_p (regno))
    4372                 :           0 :                           bitmap_set_bit (&c->dead_or_set, regno);
    4373                 :             :                       }
    4374                 :             : 
    4375                 :           0 :                     if ((regno < FIRST_PSEUDO_REGISTER
    4376                 :           0 :                          || reg_renumber[regno] >= 0
    4377                 :           0 :                          || ira_conflicts_p)
    4378                 :           0 :                         && (!DF_REF_FLAGS_IS_SET (def, DF_REF_CONDITIONAL)))
    4379                 :             :                       {
    4380                 :           0 :                         rtx reg = DF_REF_REG (def);
    4381                 :           0 :                         HOST_WIDE_INT outer_size, inner_size, start;
    4382                 :             : 
    4383                 :             :                         /* We can usually track the liveness of individual
    4384                 :             :                            bytes within a subreg.  The only exceptions are
    4385                 :             :                            subregs wrapped in ZERO_EXTRACTs and subregs whose
    4386                 :             :                            size is not known; in those cases we need to be
    4387                 :             :                            conservative and treat the definition as a partial
    4388                 :             :                            definition of the full register rather than a full
    4389                 :             :                            definition of a specific part of the register.  */
    4390                 :           0 :                         if (GET_CODE (reg) == SUBREG
    4391                 :           0 :                             && !DF_REF_FLAGS_IS_SET (def, DF_REF_ZERO_EXTRACT)
    4392                 :           0 :                             && get_subreg_tracking_sizes (reg, &outer_size,
    4393                 :             :                                                           &inner_size, &start))
    4394                 :             :                           {
    4395                 :           0 :                             HOST_WIDE_INT last = start + outer_size;
    4396                 :             : 
    4397                 :           0 :                             init_live_subregs
    4398                 :           0 :                               (bitmap_bit_p (live_relevant_regs, regno),
    4399                 :             :                                live_subregs, live_subregs_used, regno,
    4400                 :             :                                inner_size);
    4401                 :             : 
    4402                 :           0 :                             if (!DF_REF_FLAGS_IS_SET
    4403                 :             :                                 (def, DF_REF_STRICT_LOW_PART))
    4404                 :             :                               {
    4405                 :             :                                 /* Expand the range to cover entire words.
    4406                 :             :                                    Bytes added here are "don't care".  */
    4407                 :           0 :                                 start
    4408                 :           0 :                                   = start / UNITS_PER_WORD * UNITS_PER_WORD;
    4409                 :           0 :                                 last = ((last + UNITS_PER_WORD - 1)
    4410                 :           0 :                                         / UNITS_PER_WORD * UNITS_PER_WORD);
    4411                 :             :                               }
    4412                 :             : 
    4413                 :             :                             /* Ignore the paradoxical bits.  */
    4414                 :           0 :                             if (last > SBITMAP_SIZE (live_subregs[regno]))
    4415                 :             :                               last = SBITMAP_SIZE (live_subregs[regno]);
    4416                 :             : 
    4417                 :           0 :                             while (start < last)
    4418                 :             :                               {
    4419                 :           0 :                                 bitmap_clear_bit (live_subregs[regno], start);
    4420                 :           0 :                                 start++;
    4421                 :             :                               }
    4422                 :             : 
    4423                 :           0 :                             if (bitmap_empty_p (live_subregs[regno]))
    4424                 :             :                               {
    4425                 :           0 :                                 bitmap_clear_bit (live_subregs_used, regno);
    4426                 :           0 :                                 bitmap_clear_bit (live_relevant_regs, regno);
    4427                 :             :                               }
    4428                 :             :                             else
    4429                 :             :                               /* Set live_relevant_regs here because
    4430                 :             :                                  that bit has to be true to get us to
    4431                 :             :                                  look at the live_subregs fields.  */
    4432                 :           0 :                               bitmap_set_bit (live_relevant_regs, regno);
    4433                 :             :                           }
    4434                 :             :                         else
    4435                 :             :                           {
    4436                 :             :                             /* DF_REF_PARTIAL is generated for
    4437                 :             :                                subregs, STRICT_LOW_PART, and
    4438                 :             :                                ZERO_EXTRACT.  We handle the subreg
    4439                 :             :                                case above so here we have to keep from
    4440                 :             :                                modeling the def as a killing def.  */
    4441                 :           0 :                             if (!DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL))
    4442                 :             :                               {
    4443                 :           0 :                                 bitmap_clear_bit (live_subregs_used, regno);
    4444                 :           0 :                                 bitmap_clear_bit (live_relevant_regs, regno);
    4445                 :             :                               }
    4446                 :             :                           }
    4447                 :             :                       }
    4448                 :             :                   }
    4449                 :             : 
    4450                 :           0 :               bitmap_and_compl_into (live_relevant_regs, elim_regset);
    4451                 :           0 :               bitmap_copy (&c->live_throughout, live_relevant_regs);
    4452                 :             : 
    4453                 :           0 :               if (NONDEBUG_INSN_P (insn))
    4454                 :           0 :                 FOR_EACH_INSN_INFO_USE (use, insn_info)
    4455                 :             :                   {
    4456                 :           0 :                     unsigned int regno = DF_REF_REGNO (use);
    4457                 :           0 :                     rtx reg = DF_REF_REG (use);
    4458                 :             : 
    4459                 :             :                     /* DF_REF_READ_WRITE on a use means that this use
    4460                 :             :                        is fabricated from a def that is a partial set
    4461                 :             :                        to a multiword reg.  Here, we only model the
    4462                 :             :                        subreg case that is not wrapped in ZERO_EXTRACT
    4463                 :             :                        precisely so we do not need to look at the
    4464                 :             :                        fabricated use.  */
    4465                 :           0 :                     if (DF_REF_FLAGS_IS_SET (use, DF_REF_READ_WRITE)
    4466                 :             :                         && !DF_REF_FLAGS_IS_SET (use, DF_REF_ZERO_EXTRACT)
    4467                 :           0 :                         && DF_REF_FLAGS_IS_SET (use, DF_REF_SUBREG))
    4468                 :           0 :                       continue;
    4469                 :             : 
    4470                 :             :                     /* Add the last use of each var to dead_or_set.  */
    4471                 :           0 :                     if (!bitmap_bit_p (live_relevant_regs, regno))
    4472                 :             :                       {
    4473                 :           0 :                         if (regno < FIRST_PSEUDO_REGISTER)
    4474                 :             :                           {
    4475                 :           0 :                             if (!fixed_regs[regno])
    4476                 :           0 :                               bitmap_set_bit (&c->dead_or_set, regno);
    4477                 :             :                           }
    4478                 :           0 :                         else if (pseudo_for_reload_consideration_p (regno))
    4479                 :           0 :                           bitmap_set_bit (&c->dead_or_set, regno);
    4480                 :             :                       }
    4481                 :             : 
    4482                 :           0 :                     if (regno < FIRST_PSEUDO_REGISTER
    4483                 :           0 :                         || pseudo_for_reload_consideration_p (regno))
    4484                 :             :                       {
    4485                 :           0 :                         HOST_WIDE_INT outer_size, inner_size, start;
    4486                 :           0 :                         if (GET_CODE (reg) == SUBREG
    4487                 :           0 :                             && !DF_REF_FLAGS_IS_SET (use,
    4488                 :             :                                                      DF_REF_SIGN_EXTRACT
    4489                 :             :                                                      | DF_REF_ZERO_EXTRACT)
    4490                 :           0 :                             && get_subreg_tracking_sizes (reg, &outer_size,
    4491                 :             :                                                           &inner_size, &start))
    4492                 :             :                           {
    4493                 :           0 :                             HOST_WIDE_INT last = start + outer_size;
    4494                 :             : 
    4495                 :           0 :                             init_live_subregs
    4496                 :           0 :                               (bitmap_bit_p (live_relevant_regs, regno),
    4497                 :             :                                live_subregs, live_subregs_used, regno,
    4498                 :             :                                inner_size);
    4499                 :             : 
    4500                 :             :                             /* Ignore the paradoxical bits.  */
    4501                 :           0 :                             if (last > SBITMAP_SIZE (live_subregs[regno]))
    4502                 :             :                               last = SBITMAP_SIZE (live_subregs[regno]);
    4503                 :             : 
    4504                 :           0 :                             while (start < last)
    4505                 :             :                               {
    4506                 :           0 :                                 bitmap_set_bit (live_subregs[regno], start);
    4507                 :           0 :                                 start++;
    4508                 :             :                               }
    4509                 :             :                           }
    4510                 :             :                         else
    4511                 :             :                           /* Resetting the live_subregs_used is
    4512                 :             :                              effectively saying do not use the subregs
    4513                 :             :                              because we are reading the whole
    4514                 :             :                              pseudo.  */
    4515                 :           0 :                           bitmap_clear_bit (live_subregs_used, regno);
    4516                 :           0 :                         bitmap_set_bit (live_relevant_regs, regno);
    4517                 :             :                       }
    4518                 :             :                   }
    4519                 :             :             }
    4520                 :             :         }
    4521                 :             : 
    4522                 :             :       /* FIXME!! The following code is a disaster.  Reload needs to see the
    4523                 :             :          labels and jump tables that are just hanging out in between
    4524                 :             :          the basic blocks.  See pr33676.  */
    4525                 :           0 :       insn = BB_HEAD (bb);
    4526                 :             : 
    4527                 :             :       /* Skip over the barriers and cruft.  */
    4528                 :           0 :       while (insn && (BARRIER_P (insn) || NOTE_P (insn)
    4529                 :           0 :                       || BLOCK_FOR_INSN (insn) == bb))
    4530                 :           0 :         insn = PREV_INSN (insn);
    4531                 :             : 
    4532                 :             :       /* While we add anything except barriers and notes, the focus is
    4533                 :             :          to get the labels and jump tables into the
    4534                 :             :          reload_insn_chain.  */
    4535                 :           0 :       while (insn)
    4536                 :             :         {
    4537                 :           0 :           if (!NOTE_P (insn) && !BARRIER_P (insn))
    4538                 :             :             {
    4539                 :           0 :               if (BLOCK_FOR_INSN (insn))
    4540                 :             :                 break;
    4541                 :             : 
    4542                 :           0 :               c = new_insn_chain ();
    4543                 :           0 :               c->next = next;
    4544                 :           0 :               next = c;
    4545                 :           0 :               *p = c;
    4546                 :           0 :               p = &c->prev;
    4547                 :             : 
    4548                 :             :               /* The block makes no sense here, but it is what the old
    4549                 :             :                  code did.  */
    4550                 :           0 :               c->block = bb->index;
    4551                 :           0 :               c->insn = insn;
    4552                 :           0 :               bitmap_copy (&c->live_throughout, live_relevant_regs);
    4553                 :             :             }
    4554                 :           0 :           insn = PREV_INSN (insn);
    4555                 :             :         }
    4556                 :             :     }
    4557                 :             : 
    4558                 :           0 :   reload_insn_chain = c;
    4559                 :           0 :   *p = NULL;
    4560                 :             : 
    4561                 :           0 :   for (i = 0; i < (unsigned int) max_regno; i++)
    4562                 :           0 :     if (live_subregs[i] != NULL)
    4563                 :           0 :       sbitmap_free (live_subregs[i]);
    4564                 :           0 :   free (live_subregs);
    4565                 :             : 
    4566                 :           0 :   if (dump_file)
    4567                 :           0 :     print_insn_chains (dump_file);
    4568                 :           0 : }
    4569                 :             :  
    4570                 :             : /* Examine the rtx found in *LOC, which is read or written to as determined
    4571                 :             :    by TYPE.  Return false if we find a reason why an insn containing this
    4572                 :             :    rtx should not be moved (such as accesses to non-constant memory), true
    4573                 :             :    otherwise.  */
    4574                 :             : static bool
    4575                 :     6421990 : rtx_moveable_p (rtx *loc, enum op_type type)
    4576                 :             : {
    4577                 :     6428815 :   const char *fmt;
    4578                 :     6428815 :   rtx x = *loc;
    4579                 :     6428815 :   int i, j;
    4580                 :             : 
    4581                 :     6428815 :   enum rtx_code code = GET_CODE (x);
    4582                 :     6428815 :   switch (code)
    4583                 :             :     {
    4584                 :             :     case CONST:
    4585                 :             :     CASE_CONST_ANY:
    4586                 :             :     case SYMBOL_REF:
    4587                 :             :     case LABEL_REF:
    4588                 :             :       return true;
    4589                 :             : 
    4590                 :           0 :     case PC:
    4591                 :           0 :       return type == OP_IN;
    4592                 :             : 
    4593                 :     2281169 :     case REG:
    4594                 :     2281169 :       if (x == frame_pointer_rtx)
    4595                 :             :         return true;
    4596                 :     2279676 :       if (HARD_REGISTER_P (x))
    4597                 :             :         return false;
    4598                 :             :       
    4599                 :             :       return true;
    4600                 :             : 
    4601                 :      580011 :     case MEM:
    4602                 :      580011 :       if (type == OP_IN && MEM_READONLY_P (x))
    4603                 :        6757 :         return rtx_moveable_p (&XEXP (x, 0), OP_IN);
    4604                 :             :       return false;
    4605                 :             : 
    4606                 :     1984534 :     case SET:
    4607                 :     1984534 :       return (rtx_moveable_p (&SET_SRC (x), OP_IN)
    4608                 :     1984534 :               && rtx_moveable_p (&SET_DEST (x), OP_OUT));
    4609                 :             : 
    4610                 :           3 :     case STRICT_LOW_PART:
    4611                 :           3 :       return rtx_moveable_p (&XEXP (x, 0), OP_OUT);
    4612                 :             : 
    4613                 :         669 :     case ZERO_EXTRACT:
    4614                 :         669 :     case SIGN_EXTRACT:
    4615                 :         669 :       return (rtx_moveable_p (&XEXP (x, 0), type)
    4616                 :         669 :               && rtx_moveable_p (&XEXP (x, 1), OP_IN)
    4617                 :        1338 :               && rtx_moveable_p (&XEXP (x, 2), OP_IN));
    4618                 :             : 
    4619                 :          65 :     case CLOBBER:
    4620                 :          65 :       return rtx_moveable_p (&SET_DEST (x), OP_OUT);
    4621                 :             : 
    4622                 :             :     case UNSPEC_VOLATILE:
    4623                 :             :       /* It is a bad idea to consider insns with such rtl
    4624                 :             :          as moveable ones.  The insn scheduler also considers them as barrier
    4625                 :             :          for a reason.  */
    4626                 :             :       return false;
    4627                 :             : 
    4628                 :           0 :     case ASM_OPERANDS:
    4629                 :             :       /* The same is true for volatile asm: it has unknown side effects, it
    4630                 :             :          cannot be moved at will.  */
    4631                 :           0 :       if (MEM_VOLATILE_P (x))
    4632                 :             :         return false;
    4633                 :             : 
    4634                 :     1047667 :     default:
    4635                 :     1047667 :       break;
    4636                 :             :     }
    4637                 :             : 
    4638                 :     1047667 :   fmt = GET_RTX_FORMAT (code);
    4639                 :     2707195 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    4640                 :             :     {
    4641                 :     1825110 :       if (fmt[i] == 'e')
    4642                 :             :         {
    4643                 :     1429207 :           if (!rtx_moveable_p (&XEXP (x, i), type))
    4644                 :             :             return false;
    4645                 :             :         }
    4646                 :      395903 :       else if (fmt[i] == 'E')
    4647                 :      519991 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    4648                 :             :           {
    4649                 :      403842 :             if (!rtx_moveable_p (&XVECEXP (x, i, j), type))
    4650                 :             :               return false;
    4651                 :             :           }
    4652                 :             :     }
    4653                 :             :   return true;
    4654                 :             : }
    4655                 :             : 
    4656                 :             : /* A wrapper around dominated_by_p, which uses the information in UID_LUID
    4657                 :             :    to give dominance relationships between two insns I1 and I2.  */
    4658                 :             : static bool
    4659                 :    19207225 : insn_dominated_by_p (rtx i1, rtx i2, int *uid_luid)
    4660                 :             : {
    4661                 :    19207225 :   basic_block bb1 = BLOCK_FOR_INSN (i1);
    4662                 :    19207225 :   basic_block bb2 = BLOCK_FOR_INSN (i2);
    4663                 :             : 
    4664                 :    19207225 :   if (bb1 == bb2)
    4665                 :    10364620 :     return uid_luid[INSN_UID (i2)] < uid_luid[INSN_UID (i1)];
    4666                 :     8842605 :   return dominated_by_p (CDI_DOMINATORS, bb1, bb2);
    4667                 :             : }
    4668                 :             : 
    4669                 :             : /* Record the range of register numbers added by find_moveable_pseudos.  */
    4670                 :             : int first_moveable_pseudo, last_moveable_pseudo;
    4671                 :             : 
    4672                 :             : /* These two vectors hold data for every register added by
    4673                 :             :    find_movable_pseudos, with index 0 holding data for the
    4674                 :             :    first_moveable_pseudo.  */
    4675                 :             : /* The original home register.  */
    4676                 :             : static vec<rtx> pseudo_replaced_reg;
    4677                 :             : 
    4678                 :             : /* Look for instances where we have an instruction that is known to increase
    4679                 :             :    register pressure, and whose result is not used immediately.  If it is
    4680                 :             :    possible to move the instruction downwards to just before its first use,
    4681                 :             :    split its lifetime into two ranges.  We create a new pseudo to compute the
    4682                 :             :    value, and emit a move instruction just before the first use.  If, after
    4683                 :             :    register allocation, the new pseudo remains unallocated, the function
    4684                 :             :    move_unallocated_pseudos then deletes the move instruction and places
    4685                 :             :    the computation just before the first use.
    4686                 :             : 
    4687                 :             :    Such a move is safe and profitable if all the input registers remain live
    4688                 :             :    and unchanged between the original computation and its first use.  In such
    4689                 :             :    a situation, the computation is known to increase register pressure, and
    4690                 :             :    moving it is known to at least not worsen it.
    4691                 :             : 
    4692                 :             :    We restrict moves to only those cases where a register remains unallocated,
    4693                 :             :    in order to avoid interfering too much with the instruction schedule.  As
    4694                 :             :    an exception, we may move insns which only modify their input register
    4695                 :             :    (typically induction variables), as this increases the freedom for our
    4696                 :             :    intended transformation, and does not limit the second instruction
    4697                 :             :    scheduler pass.  */
    4698                 :             :    
    4699                 :             : static void
    4700                 :      996476 : find_moveable_pseudos (void)
    4701                 :             : {
    4702                 :      996476 :   unsigned i;
    4703                 :      996476 :   int max_regs = max_reg_num ();
    4704                 :      996476 :   int max_uid = get_max_uid ();
    4705                 :      996476 :   basic_block bb;
    4706                 :      996476 :   int *uid_luid = XNEWVEC (int, max_uid);
    4707                 :      996476 :   rtx_insn **closest_uses = XNEWVEC (rtx_insn *, max_regs);
    4708                 :             :   /* A set of registers which are live but not modified throughout a block.  */
    4709                 :      996476 :   bitmap_head *bb_transp_live = XNEWVEC (bitmap_head,
    4710                 :             :                                          last_basic_block_for_fn (cfun));
    4711                 :             :   /* A set of registers which only exist in a given basic block.  */
    4712                 :      996476 :   bitmap_head *bb_local = XNEWVEC (bitmap_head,
    4713                 :             :                                    last_basic_block_for_fn (cfun));
    4714                 :             :   /* A set of registers which are set once, in an instruction that can be
    4715                 :             :      moved freely downwards, but are otherwise transparent to a block.  */
    4716                 :      996476 :   bitmap_head *bb_moveable_reg_sets = XNEWVEC (bitmap_head,
    4717                 :             :                                                last_basic_block_for_fn (cfun));
    4718                 :      996476 :   auto_bitmap live, used, set, interesting, unusable_as_input;
    4719                 :      996476 :   bitmap_iterator bi;
    4720                 :             : 
    4721                 :      996476 :   first_moveable_pseudo = max_regs;
    4722                 :      996476 :   pseudo_replaced_reg.release ();
    4723                 :      996476 :   pseudo_replaced_reg.safe_grow_cleared (max_regs, true);
    4724                 :             : 
    4725                 :      996476 :   df_analyze ();
    4726                 :      996476 :   calculate_dominance_info (CDI_DOMINATORS);
    4727                 :             : 
    4728                 :      996476 :   i = 0;
    4729                 :    11039869 :   FOR_EACH_BB_FN (bb, cfun)
    4730                 :             :     {
    4731                 :    10043393 :       rtx_insn *insn;
    4732                 :    10043393 :       bitmap transp = bb_transp_live + bb->index;
    4733                 :    10043393 :       bitmap moveable = bb_moveable_reg_sets + bb->index;
    4734                 :    10043393 :       bitmap local = bb_local + bb->index;
    4735                 :             : 
    4736                 :    10043393 :       bitmap_initialize (local, 0);
    4737                 :    10043393 :       bitmap_initialize (transp, 0);
    4738                 :    10043393 :       bitmap_initialize (moveable, 0);
    4739                 :    10043393 :       bitmap_copy (live, df_get_live_out (bb));
    4740                 :    10043393 :       bitmap_and_into (live, df_get_live_in (bb));
    4741                 :    10043393 :       bitmap_copy (transp, live);
    4742                 :    10043393 :       bitmap_clear (moveable);
    4743                 :    10043393 :       bitmap_clear (live);
    4744                 :    10043393 :       bitmap_clear (used);
    4745                 :    10043393 :       bitmap_clear (set);
    4746                 :   122934257 :       FOR_BB_INSNS (bb, insn)
    4747                 :   112890864 :         if (NONDEBUG_INSN_P (insn))
    4748                 :             :           {
    4749                 :    54359487 :             df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4750                 :    54359487 :             df_ref def, use;
    4751                 :             : 
    4752                 :    54359487 :             uid_luid[INSN_UID (insn)] = i++;
    4753                 :             :             
    4754                 :    54359487 :             def = df_single_def (insn_info);
    4755                 :    54359487 :             use = df_single_use (insn_info);
    4756                 :    54359487 :             if (use
    4757                 :    54359487 :                 && def
    4758                 :    18004360 :                 && DF_REF_REGNO (use) == DF_REF_REGNO (def)
    4759                 :      583657 :                 && !bitmap_bit_p (set, DF_REF_REGNO (use))
    4760                 :    54425115 :                 && rtx_moveable_p (&PATTERN (insn), OP_IN))
    4761                 :             :               {
    4762                 :       28901 :                 unsigned regno = DF_REF_REGNO (use);
    4763                 :       28901 :                 bitmap_set_bit (moveable, regno);
    4764                 :       28901 :                 bitmap_set_bit (set, regno);
    4765                 :       28901 :                 bitmap_set_bit (used, regno);
    4766                 :       28901 :                 bitmap_clear_bit (transp, regno);
    4767                 :       28901 :                 continue;
    4768                 :       28901 :               }
    4769                 :   120730768 :             FOR_EACH_INSN_INFO_USE (use, insn_info)
    4770                 :             :               {
    4771                 :    66400182 :                 unsigned regno = DF_REF_REGNO (use);
    4772                 :    66400182 :                 bitmap_set_bit (used, regno);
    4773                 :    66400182 :                 if (bitmap_clear_bit (moveable, regno))
    4774                 :       15697 :                   bitmap_clear_bit (transp, regno);
    4775                 :             :               }
    4776                 :             : 
    4777                 :   461428153 :             FOR_EACH_INSN_INFO_DEF (def, insn_info)
    4778                 :             :               {
    4779                 :   407097567 :                 unsigned regno = DF_REF_REGNO (def);
    4780                 :   407097567 :                 bitmap_set_bit (set, regno);
    4781                 :   407097567 :                 bitmap_clear_bit (transp, regno);
    4782                 :   407097567 :                 bitmap_clear_bit (moveable, regno);
    4783                 :             :               }
    4784                 :             :           }
    4785                 :             :     }
    4786                 :             : 
    4787                 :    11039869 :   FOR_EACH_BB_FN (bb, cfun)
    4788                 :             :     {
    4789                 :    10043393 :       bitmap local = bb_local + bb->index;
    4790                 :    10043393 :       rtx_insn *insn;
    4791                 :             : 
    4792                 :   122934257 :       FOR_BB_INSNS (bb, insn)
    4793                 :   112890864 :         if (NONDEBUG_INSN_P (insn))
    4794                 :             :           {
    4795                 :    54359487 :             df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4796                 :    54359487 :             rtx_insn *def_insn;
    4797                 :    54359487 :             rtx closest_use, note;
    4798                 :    54359487 :             df_ref def, use;
    4799                 :    54359487 :             unsigned regno;
    4800                 :    54359487 :             bool all_dominated, all_local;
    4801                 :    54359487 :             machine_mode mode;
    4802                 :             : 
    4803                 :    54359487 :             def = df_single_def (insn_info);
    4804                 :             :             /* There must be exactly one def in this insn.  */
    4805                 :    29865815 :             if (!def || !single_set (insn))
    4806                 :    24575072 :               continue;
    4807                 :             :             /* This must be the only definition of the reg.  We also limit
    4808                 :             :                which modes we deal with so that we can assume we can generate
    4809                 :             :                move instructions.  */
    4810                 :    29784415 :             regno = DF_REF_REGNO (def);
    4811                 :    29784415 :             mode = GET_MODE (DF_REF_REG (def));
    4812                 :    29784415 :             if (DF_REG_DEF_COUNT (regno) != 1
    4813                 :    11328624 :                 || !DF_REF_INSN_INFO (def)
    4814                 :    11328624 :                 || HARD_REGISTER_NUM_P (regno)
    4815                 :    11298658 :                 || DF_REG_EQ_USE_COUNT (regno) > 0
    4816                 :    10819208 :                 || (!INTEGRAL_MODE_P (mode)
    4817                 :             :                     && !FLOAT_MODE_P (mode)
    4818                 :             :                     && !OPAQUE_MODE_P (mode)))
    4819                 :    18965207 :               continue;
    4820                 :    10819208 :             def_insn = DF_REF_INSN (def);
    4821                 :             : 
    4822                 :    18299300 :             for (note = REG_NOTES (def_insn); note; note = XEXP (note, 1))
    4823                 :     9879405 :               if (REG_NOTE_KIND (note) == REG_EQUIV && MEM_P (XEXP (note, 0)))
    4824                 :             :                 break;
    4825                 :             :                 
    4826                 :    10819208 :             if (note)
    4827                 :             :               {
    4828                 :     2399313 :                 if (dump_file)
    4829                 :          68 :                   fprintf (dump_file, "Ignoring reg %d, has equiv memory\n",
    4830                 :             :                            regno);
    4831                 :     2399313 :                 bitmap_set_bit (unusable_as_input, regno);
    4832                 :     2399313 :                 continue;
    4833                 :             :               }
    4834                 :             : 
    4835                 :     8419895 :             use = DF_REG_USE_CHAIN (regno);
    4836                 :     8419895 :             all_dominated = true;
    4837                 :     8419895 :             all_local = true;
    4838                 :     8419895 :             closest_use = NULL_RTX;
    4839                 :    24238140 :             for (; use; use = DF_REF_NEXT_REG (use))
    4840                 :             :               {
    4841                 :    15818245 :                 rtx_insn *insn;
    4842                 :    15818245 :                 if (!DF_REF_INSN_INFO (use))
    4843                 :             :                   {
    4844                 :             :                     all_dominated = false;
    4845                 :             :                     all_local = false;
    4846                 :             :                     break;
    4847                 :             :                   }
    4848                 :    15818245 :                 insn = DF_REF_INSN (use);
    4849                 :    15818245 :                 if (DEBUG_INSN_P (insn))
    4850                 :     1840204 :                   continue;
    4851                 :    13978041 :                 if (BLOCK_FOR_INSN (insn) != BLOCK_FOR_INSN (def_insn))
    4852                 :     5367167 :                   all_local = false;
    4853                 :    13978041 :                 if (!insn_dominated_by_p (insn, def_insn, uid_luid))
    4854                 :        8771 :                   all_dominated = false;
    4855                 :    13978041 :                 if (closest_use != insn && closest_use != const0_rtx)
    4856                 :             :                   {
    4857                 :    12408032 :                     if (closest_use == NULL_RTX)
    4858                 :             :                       closest_use = insn;
    4859                 :     4046054 :                     else if (insn_dominated_by_p (closest_use, insn, uid_luid))
    4860                 :             :                       closest_use = insn;
    4861                 :     1183130 :                     else if (!insn_dominated_by_p (insn, closest_use, uid_luid))
    4862                 :      555336 :                       closest_use = const0_rtx;
    4863                 :             :                   }
    4864                 :             :               }
    4865                 :     8419895 :             if (!all_dominated)
    4866                 :             :               {
    4867                 :        4602 :                 if (dump_file)
    4868                 :           0 :                   fprintf (dump_file, "Reg %d not all uses dominated by set\n",
    4869                 :             :                            regno);
    4870                 :        4602 :                 continue;
    4871                 :             :               }
    4872                 :     8415293 :             if (all_local)
    4873                 :     6090072 :               bitmap_set_bit (local, regno);
    4874                 :     7861591 :             if (closest_use == const0_rtx || closest_use == NULL
    4875                 :    16218967 :                 || next_nonnote_nondebug_insn (def_insn) == closest_use)
    4876                 :             :               {
    4877                 :     5284644 :                 if (dump_file)
    4878                 :          95 :                   fprintf (dump_file, "Reg %d uninteresting%s\n", regno,
    4879                 :          95 :                            closest_use == const0_rtx || closest_use == NULL
    4880                 :             :                            ? " (no unique first use)" : "");
    4881                 :     5284644 :                 continue;
    4882                 :             :               }
    4883                 :             : 
    4884                 :     3130649 :             bitmap_set_bit (interesting, regno);
    4885                 :             :             /* If we get here, we know closest_use is a non-NULL insn
    4886                 :             :                (as opposed to const_0_rtx).  */
    4887                 :     3130649 :             closest_uses[regno] = as_a <rtx_insn *> (closest_use);
    4888                 :             : 
    4889                 :     3130649 :             if (dump_file && (all_local || all_dominated))
    4890                 :             :               {
    4891                 :          78 :                 fprintf (dump_file, "Reg %u:", regno);
    4892                 :          78 :                 if (all_local)
    4893                 :          14 :                   fprintf (dump_file, " local to bb %d", bb->index);
    4894                 :          78 :                 if (all_dominated)
    4895                 :          78 :                   fprintf (dump_file, " def dominates all uses");
    4896                 :          78 :                 if (closest_use != const0_rtx)
    4897                 :          78 :                   fprintf (dump_file, " has unique first use");
    4898                 :          78 :                 fputs ("\n", dump_file);
    4899                 :             :               }
    4900                 :             :           }
    4901                 :             :     }
    4902                 :             : 
    4903                 :     4127125 :   EXECUTE_IF_SET_IN_BITMAP (interesting, 0, i, bi)
    4904                 :             :     {
    4905                 :     3130649 :       df_ref def = DF_REG_DEF_CHAIN (i);
    4906                 :     3130649 :       rtx_insn *def_insn = DF_REF_INSN (def);
    4907                 :     3130649 :       basic_block def_block = BLOCK_FOR_INSN (def_insn);
    4908                 :     3130649 :       bitmap def_bb_local = bb_local + def_block->index;
    4909                 :     3130649 :       bitmap def_bb_moveable = bb_moveable_reg_sets + def_block->index;
    4910                 :     3130649 :       bitmap def_bb_transp = bb_transp_live + def_block->index;
    4911                 :     3130649 :       bool local_to_bb_p = bitmap_bit_p (def_bb_local, i);
    4912                 :     3130649 :       rtx_insn *use_insn = closest_uses[i];
    4913                 :     3130649 :       df_ref use;
    4914                 :     3130649 :       bool all_ok = true;
    4915                 :     3130649 :       bool all_transp = true;
    4916                 :             : 
    4917                 :     3130649 :       if (!REG_P (DF_REF_REG (def)))
    4918                 :       39044 :         continue;
    4919                 :             : 
    4920                 :     3091605 :       if (!local_to_bb_p)
    4921                 :             :         {
    4922                 :     1129048 :           if (dump_file)
    4923                 :          64 :             fprintf (dump_file, "Reg %u not local to one basic block\n",
    4924                 :             :                      i);
    4925                 :     1129048 :           continue;
    4926                 :             :         }
    4927                 :     1962557 :       if (reg_equiv_init (i) != NULL_RTX)
    4928                 :             :         {
    4929                 :       43619 :           if (dump_file)
    4930                 :           0 :             fprintf (dump_file, "Ignoring reg %u with equiv init insn\n",
    4931                 :             :                      i);
    4932                 :       43619 :           continue;
    4933                 :             :         }
    4934                 :     1918938 :       if (!rtx_moveable_p (&PATTERN (def_insn), OP_IN))
    4935                 :             :         {
    4936                 :     1343346 :           if (dump_file)
    4937                 :          14 :             fprintf (dump_file, "Found def insn %d for %d to be not moveable\n",
    4938                 :          14 :                      INSN_UID (def_insn), i);
    4939                 :     1343346 :           continue;
    4940                 :             :         }
    4941                 :      575592 :       if (dump_file)
    4942                 :           0 :         fprintf (dump_file, "Examining insn %d, def for %d\n",
    4943                 :           0 :                  INSN_UID (def_insn), i);
    4944                 :     1298279 :       FOR_EACH_INSN_USE (use, def_insn)
    4945                 :             :         {
    4946                 :      778653 :           unsigned regno = DF_REF_REGNO (use);
    4947                 :      778653 :           if (bitmap_bit_p (unusable_as_input, regno))
    4948                 :             :             {
    4949                 :       55966 :               all_ok = false;
    4950                 :       55966 :               if (dump_file)
    4951                 :           0 :                 fprintf (dump_file, "  found unusable input reg %u.\n", regno);
    4952                 :             :               break;
    4953                 :             :             }
    4954                 :      722687 :           if (!bitmap_bit_p (def_bb_transp, regno))
    4955                 :             :             {
    4956                 :      678114 :               if (bitmap_bit_p (def_bb_moveable, regno)
    4957                 :      678114 :                   && !control_flow_insn_p (use_insn))
    4958                 :             :                 {
    4959                 :          21 :                   if (modified_between_p (DF_REF_REG (use), def_insn, use_insn))
    4960                 :             :                     {
    4961                 :           1 :                       rtx_insn *x = NEXT_INSN (def_insn);
    4962                 :           2 :                       while (!modified_in_p (DF_REF_REG (use), x))
    4963                 :             :                         {
    4964                 :           0 :                           gcc_assert (x != use_insn);
    4965                 :           0 :                           x = NEXT_INSN (x);
    4966                 :             :                         }
    4967                 :           1 :                       if (dump_file)
    4968                 :           0 :                         fprintf (dump_file, "  input reg %u modified but insn %d moveable\n",
    4969                 :           0 :                                  regno, INSN_UID (x));
    4970                 :           1 :                       emit_insn_after (PATTERN (x), use_insn);
    4971                 :           1 :                       set_insn_deleted (x);
    4972                 :             :                     }
    4973                 :             :                   else
    4974                 :             :                     {
    4975                 :          20 :                       if (dump_file)
    4976                 :           0 :                         fprintf (dump_file, "  input reg %u modified between def and use\n",
    4977                 :             :                                  regno);
    4978                 :             :                       all_transp = false;
    4979                 :             :                     }
    4980                 :             :                 }
    4981                 :             :               else
    4982                 :             :                 all_transp = false;
    4983                 :             :             }
    4984                 :             :         }
    4985                 :           0 :       if (!all_ok)
    4986                 :       55966 :         continue;
    4987                 :      519626 :       if (!dbg_cnt (ira_move))
    4988                 :             :         break;
    4989                 :      519626 :       if (dump_file)
    4990                 :           0 :         fprintf (dump_file, "  all ok%s\n", all_transp ? " and transp" : "");
    4991                 :             : 
    4992                 :      519626 :       if (all_transp)
    4993                 :             :         {
    4994                 :       13201 :           rtx def_reg = DF_REF_REG (def);
    4995                 :       13201 :           rtx newreg = ira_create_new_reg (def_reg);
    4996                 :       13201 :           if (validate_change (def_insn, DF_REF_REAL_LOC (def), newreg, 0))
    4997                 :             :             {
    4998                 :       13201 :               unsigned nregno = REGNO (newreg);
    4999                 :       13201 :               emit_insn_before (gen_move_insn (def_reg, newreg), use_insn);
    5000                 :       13201 :               nregno -= max_regs;
    5001                 :       13201 :               pseudo_replaced_reg[nregno] = def_reg;
    5002                 :             :             }
    5003                 :             :         }
    5004                 :             :     }
    5005                 :             :   
    5006                 :    11039869 :   FOR_EACH_BB_FN (bb, cfun)
    5007                 :             :     {
    5008                 :    10043393 :       bitmap_clear (bb_local + bb->index);
    5009                 :    10043393 :       bitmap_clear (bb_transp_live + bb->index);
    5010                 :    10043393 :       bitmap_clear (bb_moveable_reg_sets + bb->index);
    5011                 :             :     }
    5012                 :      996476 :   free (uid_luid);
    5013                 :      996476 :   free (closest_uses);
    5014                 :      996476 :   free (bb_local);
    5015                 :      996476 :   free (bb_transp_live);
    5016                 :      996476 :   free (bb_moveable_reg_sets);
    5017                 :             : 
    5018                 :      996476 :   last_moveable_pseudo = max_reg_num ();
    5019                 :             : 
    5020                 :      996476 :   fix_reg_equiv_init ();
    5021                 :      996476 :   expand_reg_info ();
    5022                 :      996476 :   regstat_free_n_sets_and_refs ();
    5023                 :      996476 :   regstat_free_ri ();
    5024                 :      996476 :   regstat_init_n_sets_and_refs ();
    5025                 :      996476 :   regstat_compute_ri ();
    5026                 :      996476 :   free_dominance_info (CDI_DOMINATORS);
    5027                 :      996476 : }
    5028                 :             : 
    5029                 :             : /* If SET pattern SET is an assignment from a hard register to a pseudo which
    5030                 :             :    is live at CALL_DOM (if non-NULL, otherwise this check is omitted), return
    5031                 :             :    the destination.  Otherwise return NULL.  */
    5032                 :             : 
    5033                 :             : static rtx
    5034                 :     1999891 : interesting_dest_for_shprep_1 (rtx set, basic_block call_dom)
    5035                 :             : {
    5036                 :     1999891 :   rtx src = SET_SRC (set);
    5037                 :     1999891 :   rtx dest = SET_DEST (set);
    5038                 :      660719 :   if (!REG_P (src) || !HARD_REGISTER_P (src)
    5039                 :      525519 :       || !REG_P (dest) || HARD_REGISTER_P (dest)
    5040                 :     2506716 :       || (call_dom && !bitmap_bit_p (df_get_live_in (call_dom), REGNO (dest))))
    5041                 :     1579066 :     return NULL;
    5042                 :             :   return dest;
    5043                 :             : }
    5044                 :             : 
    5045                 :             : /* If insn is interesting for parameter range-splitting shrink-wrapping
    5046                 :             :    preparation, i.e. it is a single set from a hard register to a pseudo, which
    5047                 :             :    is live at CALL_DOM (if non-NULL, otherwise this check is omitted), or a
    5048                 :             :    parallel statement with only one such statement, return the destination.
    5049                 :             :    Otherwise return NULL.  */
    5050                 :             : 
    5051                 :             : static rtx
    5052                 :     4042446 : interesting_dest_for_shprep (rtx_insn *insn, basic_block call_dom)
    5053                 :             : {
    5054                 :     4042446 :   if (!INSN_P (insn))
    5055                 :             :     return NULL;
    5056                 :     3205834 :   rtx pat = PATTERN (insn);
    5057                 :     3205834 :   if (GET_CODE (pat) == SET)
    5058                 :     1769797 :     return interesting_dest_for_shprep_1 (pat, call_dom);
    5059                 :             : 
    5060                 :     1436037 :   if (GET_CODE (pat) != PARALLEL)
    5061                 :             :     return NULL;
    5062                 :             :   rtx ret = NULL;
    5063                 :      596949 :   for (int i = 0; i < XVECLEN (pat, 0); i++)
    5064                 :             :     {
    5065                 :      405167 :       rtx sub = XVECEXP (pat, 0, i);
    5066                 :      405167 :       if (GET_CODE (sub) == USE || GET_CODE (sub) == CLOBBER)
    5067                 :      168365 :         continue;
    5068                 :      236802 :       if (GET_CODE (sub) != SET
    5069                 :      236802 :           || side_effects_p (sub))
    5070                 :        6708 :         return NULL;
    5071                 :      230094 :       rtx dest = interesting_dest_for_shprep_1 (sub, call_dom);
    5072                 :      230094 :       if (dest && ret)
    5073                 :             :         return NULL;
    5074                 :      230094 :       if (dest)
    5075                 :      398459 :         ret = dest;
    5076                 :             :     }
    5077                 :             :   return ret;
    5078                 :             : }
    5079                 :             : 
    5080                 :             : /* Split live ranges of pseudos that are loaded from hard registers in the
    5081                 :             :    first BB in a BB that dominates all non-sibling call if such a BB can be
    5082                 :             :    found and is not in a loop.  Return true if the function has made any
    5083                 :             :    changes.  */
    5084                 :             : 
    5085                 :             : static bool
    5086                 :      996476 : split_live_ranges_for_shrink_wrap (void)
    5087                 :             : {
    5088                 :      996476 :   basic_block bb, call_dom = NULL;
    5089                 :      996476 :   basic_block first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    5090                 :      996476 :   rtx_insn *insn, *last_interesting_insn = NULL;
    5091                 :      996476 :   auto_bitmap need_new, reachable;
    5092                 :      996476 :   vec<basic_block> queue;
    5093                 :             : 
    5094                 :      996476 :   if (!SHRINK_WRAPPING_ENABLED)
    5095                 :         128 :     return false;
    5096                 :             : 
    5097                 :      996348 :   queue.create (n_basic_blocks_for_fn (cfun));
    5098                 :             : 
    5099                 :     6902954 :   FOR_EACH_BB_FN (bb, cfun)
    5100                 :    65527665 :     FOR_BB_INSNS (bb, insn)
    5101                 :    60931449 :       if (CALL_P (insn) && !SIBLING_CALL_P (insn))
    5102                 :             :         {
    5103                 :     1703232 :           if (bb == first)
    5104                 :             :             {
    5105                 :      392842 :               queue.release ();
    5106                 :      392842 :               return false;
    5107                 :             :             }
    5108                 :             : 
    5109                 :     1310390 :           bitmap_set_bit (need_new, bb->index);
    5110                 :     1310390 :           bitmap_set_bit (reachable, bb->index);
    5111                 :     1310390 :           queue.quick_push (bb);
    5112                 :     1310390 :           break;
    5113                 :             :         }
    5114                 :             : 
    5115                 :      603506 :   if (queue.is_empty ())
    5116                 :             :     {
    5117                 :      359360 :       queue.release ();
    5118                 :      359360 :       return false;
    5119                 :             :     }
    5120                 :             : 
    5121                 :     3855921 :   while (!queue.is_empty ())
    5122                 :             :     {
    5123                 :     3611775 :       edge e;
    5124                 :     3611775 :       edge_iterator ei;
    5125                 :             : 
    5126                 :     3611775 :       bb = queue.pop ();
    5127                 :     8646465 :       FOR_EACH_EDGE (e, ei, bb->succs)
    5128                 :     5034690 :         if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
    5129                 :     5034690 :             && bitmap_set_bit (reachable, e->dest->index))
    5130                 :     2301385 :           queue.quick_push (e->dest);
    5131                 :             :     }
    5132                 :      244146 :   queue.release ();
    5133                 :             : 
    5134                 :     3618663 :   FOR_BB_INSNS (first, insn)
    5135                 :             :     {
    5136                 :     3374794 :       rtx dest = interesting_dest_for_shprep (insn, NULL);
    5137                 :     3374794 :       if (!dest)
    5138                 :     3003008 :         continue;
    5139                 :             : 
    5140                 :      371786 :       if (DF_REG_DEF_COUNT (REGNO (dest)) > 1)
    5141                 :             :         return false;
    5142                 :             : 
    5143                 :      371509 :       for (df_ref use = DF_REG_USE_CHAIN (REGNO(dest));
    5144                 :     2485067 :            use;
    5145                 :     2113558 :            use = DF_REF_NEXT_REG (use))
    5146                 :             :         {
    5147                 :     2113558 :           int ubbi = DF_REF_BB (use)->index;
    5148                 :             : 
    5149                 :             :           /* Only non debug insns should be taken into account.  */
    5150                 :     2113558 :           if (NONDEBUG_INSN_P (DF_REF_INSN (use))
    5151                 :     2113558 :               && bitmap_bit_p (reachable, ubbi))
    5152                 :     1014379 :             bitmap_set_bit (need_new, ubbi);
    5153                 :             :         }
    5154                 :             :       last_interesting_insn = insn;
    5155                 :             :     }
    5156                 :             : 
    5157                 :      243869 :   if (!last_interesting_insn)
    5158                 :             :     return false;
    5159                 :             : 
    5160                 :      173248 :   call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, need_new);
    5161                 :      173248 :   if (call_dom == first)
    5162                 :             :     return false;
    5163                 :             : 
    5164                 :       90842 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    5165                 :      203618 :   while (bb_loop_depth (call_dom) > 0)
    5166                 :       21934 :     call_dom = get_immediate_dominator (CDI_DOMINATORS, call_dom);
    5167                 :       90842 :   loop_optimizer_finalize ();
    5168                 :             : 
    5169                 :       90842 :   if (call_dom == first)
    5170                 :             :     return false;
    5171                 :             : 
    5172                 :       78978 :   calculate_dominance_info (CDI_POST_DOMINATORS);
    5173                 :       78978 :   if (dominated_by_p (CDI_POST_DOMINATORS, first, call_dom))
    5174                 :             :     {
    5175                 :        7223 :       free_dominance_info (CDI_POST_DOMINATORS);
    5176                 :        7223 :       return false;
    5177                 :             :     }
    5178                 :       71755 :   free_dominance_info (CDI_POST_DOMINATORS);
    5179                 :             : 
    5180                 :       71755 :   if (dump_file)
    5181                 :           2 :     fprintf (dump_file, "Will split live ranges of parameters at BB %i\n",
    5182                 :             :              call_dom->index);
    5183                 :             : 
    5184                 :       71755 :   bool ret = false;
    5185                 :      718498 :   FOR_BB_INSNS (first, insn)
    5186                 :             :     {
    5187                 :      667652 :       rtx dest = interesting_dest_for_shprep (insn, call_dom);
    5188                 :      667652 :       if (!dest || dest == pic_offset_table_rtx)
    5189                 :      618613 :         continue;
    5190                 :             : 
    5191                 :       49039 :       bool need_newreg = false;
    5192                 :       49039 :       df_ref use, next;
    5193                 :       61579 :       for (use = DF_REG_USE_CHAIN (REGNO (dest)); use; use = next)
    5194                 :             :         {
    5195                 :       61508 :           rtx_insn *uin = DF_REF_INSN (use);
    5196                 :       61508 :           next = DF_REF_NEXT_REG (use);
    5197                 :             : 
    5198                 :       61508 :           if (DEBUG_INSN_P (uin))
    5199                 :         466 :             continue;
    5200                 :             : 
    5201                 :       61042 :           basic_block ubb = BLOCK_FOR_INSN (uin);
    5202                 :       61042 :           if (ubb == call_dom
    5203                 :       61042 :               || dominated_by_p (CDI_DOMINATORS, ubb, call_dom))
    5204                 :             :             {
    5205                 :             :               need_newreg = true;
    5206                 :             :               break;
    5207                 :             :             }
    5208                 :             :         }
    5209                 :             : 
    5210                 :       49039 :       if (need_newreg)
    5211                 :             :         {
    5212                 :       48968 :           rtx newreg = ira_create_new_reg (dest);
    5213                 :             : 
    5214                 :      354573 :           for (use = DF_REG_USE_CHAIN (REGNO (dest)); use; use = next)
    5215                 :             :             {
    5216                 :      305605 :               rtx_insn *uin = DF_REF_INSN (use);
    5217                 :      305605 :               next = DF_REF_NEXT_REG (use);
    5218                 :             : 
    5219                 :      305605 :               basic_block ubb = BLOCK_FOR_INSN (uin);
    5220                 :      305605 :               if (ubb == call_dom
    5221                 :      305605 :                   || dominated_by_p (CDI_DOMINATORS, ubb, call_dom))
    5222                 :      223270 :                 validate_change (uin, DF_REF_REAL_LOC (use), newreg, true);
    5223                 :             :             }
    5224                 :             : 
    5225                 :       48968 :           rtx_insn *new_move = gen_move_insn (newreg, dest);
    5226                 :       48968 :           emit_insn_after (new_move, bb_note (call_dom));
    5227                 :       48968 :           if (dump_file)
    5228                 :             :             {
    5229                 :           2 :               fprintf (dump_file, "Split live-range of register ");
    5230                 :           2 :               print_rtl_single (dump_file, dest);
    5231                 :             :             }
    5232                 :             :           ret = true;
    5233                 :             :         }
    5234                 :             : 
    5235                 :       49039 :       if (insn == last_interesting_insn)
    5236                 :             :         break;
    5237                 :             :     }
    5238                 :       71755 :   apply_change_group ();
    5239                 :       71755 :   return ret;
    5240                 :      996476 : }
    5241                 :             : 
    5242                 :             : /* Perform the second half of the transformation started in
    5243                 :             :    find_moveable_pseudos.  We look for instances where the newly introduced
    5244                 :             :    pseudo remains unallocated, and remove it by moving the definition to
    5245                 :             :    just before its use, replacing the move instruction generated by
    5246                 :             :    find_moveable_pseudos.  */
    5247                 :             : static void
    5248                 :      996476 : move_unallocated_pseudos (void)
    5249                 :             : {
    5250                 :      996476 :   int i;
    5251                 :     1009677 :   for (i = first_moveable_pseudo; i < last_moveable_pseudo; i++)
    5252                 :       13201 :     if (reg_renumber[i] < 0)
    5253                 :             :       {
    5254                 :        3341 :         int idx = i - first_moveable_pseudo;
    5255                 :        3341 :         rtx other_reg = pseudo_replaced_reg[idx];
    5256                 :             :         /* The iterating range [first_moveable_pseudo, last_moveable_pseudo)
    5257                 :             :            covers every new pseudo created in find_moveable_pseudos,
    5258                 :             :            regardless of the validation with it is successful or not.
    5259                 :             :            So we need to skip the pseudos which were used in those failed
    5260                 :             :            validations to avoid unexpected DF info and consequent ICE.
    5261                 :             :            We only set pseudo_replaced_reg[] when the validation is successful
    5262                 :             :            in find_moveable_pseudos, it's enough to check it here.  */
    5263                 :        3341 :         if (!other_reg)
    5264                 :           0 :           continue;
    5265                 :        3341 :         rtx_insn *def_insn = DF_REF_INSN (DF_REG_DEF_CHAIN (i));
    5266                 :             :         /* The use must follow all definitions of OTHER_REG, so we can
    5267                 :             :            insert the new definition immediately after any of them.  */
    5268                 :        3341 :         df_ref other_def = DF_REG_DEF_CHAIN (REGNO (other_reg));
    5269                 :        3341 :         rtx_insn *move_insn = DF_REF_INSN (other_def);
    5270                 :        3341 :         rtx_insn *newinsn = emit_insn_after (PATTERN (def_insn), move_insn);
    5271                 :        3341 :         rtx set;
    5272                 :        3341 :         int success;
    5273                 :             : 
    5274                 :        3341 :         if (dump_file)
    5275                 :           0 :           fprintf (dump_file, "moving def of %d (insn %d now) ",
    5276                 :           0 :                    REGNO (other_reg), INSN_UID (def_insn));
    5277                 :             : 
    5278                 :        3341 :         delete_insn (move_insn);
    5279                 :        6682 :         while ((other_def = DF_REG_DEF_CHAIN (REGNO (other_reg))))
    5280                 :           0 :           delete_insn (DF_REF_INSN (other_def));
    5281                 :        3341 :         delete_insn (def_insn);
    5282                 :             : 
    5283                 :        3341 :         set = single_set (newinsn);
    5284                 :        3341 :         success = validate_change (newinsn, &SET_DEST (set), other_reg, 0);
    5285                 :        3341 :         gcc_assert (success);
    5286                 :        3341 :         if (dump_file)
    5287                 :           0 :           fprintf (dump_file, " %d) rather than keep unallocated replacement %d\n",
    5288                 :           0 :                    INSN_UID (newinsn), i);
    5289                 :        3341 :         SET_REG_N_REFS (i, 0);
    5290                 :             :       }
    5291                 :             : 
    5292                 :      996476 :   first_moveable_pseudo = last_moveable_pseudo = 0;
    5293                 :      996476 : }
    5294                 :             : 
    5295                 :             : 
    5296                 :             : 
    5297                 :             : /* Code dealing with scratches (changing them onto
    5298                 :             :    pseudos and restoring them from the pseudos).
    5299                 :             : 
    5300                 :             :    We change scratches into pseudos at the beginning of IRA to
    5301                 :             :    simplify dealing with them (conflicts, hard register assignments).
    5302                 :             : 
    5303                 :             :    If the pseudo denoting scratch was spilled it means that we do not
    5304                 :             :    need a hard register for it.  Such pseudos are transformed back to
    5305                 :             :    scratches at the end of LRA.  */
    5306                 :             : 
    5307                 :             : /* Description of location of a former scratch operand.  */
    5308                 :             : struct sloc
    5309                 :             : {
    5310                 :             :   rtx_insn *insn; /* Insn where the scratch was.  */
    5311                 :             :   int nop;  /* Number of the operand which was a scratch.  */
    5312                 :             :   unsigned regno; /* regno gnerated instead of scratch */
    5313                 :             :   int icode;  /* Original icode from which scratch was removed.  */
    5314                 :             : };
    5315                 :             : 
    5316                 :             : typedef struct sloc *sloc_t;
    5317                 :             : 
    5318                 :             : /* Locations of the former scratches.  */
    5319                 :             : static vec<sloc_t> scratches;
    5320                 :             : 
    5321                 :             : /* Bitmap of scratch regnos.  */
    5322                 :             : static bitmap_head scratch_bitmap;
    5323                 :             : 
    5324                 :             : /* Bitmap of scratch operands.  */
    5325                 :             : static bitmap_head scratch_operand_bitmap;
    5326                 :             : 
    5327                 :             : /* Return true if pseudo REGNO is made of SCRATCH.  */
    5328                 :             : bool
    5329                 :   355792103 : ira_former_scratch_p (int regno)
    5330                 :             : {
    5331                 :   355792103 :   return bitmap_bit_p (&scratch_bitmap, regno);
    5332                 :             : }
    5333                 :             : 
    5334                 :             : /* Return true if the operand NOP of INSN is a former scratch.  */
    5335                 :             : bool
    5336                 :           0 : ira_former_scratch_operand_p (rtx_insn *insn, int nop)
    5337                 :             : {
    5338                 :           0 :   return bitmap_bit_p (&scratch_operand_bitmap,
    5339                 :           0 :                        INSN_UID (insn) * MAX_RECOG_OPERANDS + nop) != 0;
    5340                 :             : }
    5341                 :             : 
    5342                 :             : /* Register operand NOP in INSN as a former scratch.  It will be
    5343                 :             :    changed to scratch back, if it is necessary, at the LRA end.  */
    5344                 :             : void
    5345                 :       91193 : ira_register_new_scratch_op (rtx_insn *insn, int nop, int icode)
    5346                 :             : {
    5347                 :       91193 :   rtx op = *recog_data.operand_loc[nop];
    5348                 :       91193 :   sloc_t loc = XNEW (struct sloc);
    5349                 :       91193 :   ira_assert (REG_P (op));
    5350                 :       91193 :   loc->insn = insn;
    5351                 :       91193 :   loc->nop = nop;
    5352                 :       91193 :   loc->regno = REGNO (op);
    5353                 :       91193 :   loc->icode = icode;
    5354                 :       91193 :   scratches.safe_push (loc);
    5355                 :       91193 :   bitmap_set_bit (&scratch_bitmap, REGNO (op));
    5356                 :      182386 :   bitmap_set_bit (&scratch_operand_bitmap,
    5357                 :       91193 :                   INSN_UID (insn) * MAX_RECOG_OPERANDS + nop);
    5358                 :       91193 :   add_reg_note (insn, REG_UNUSED, op);
    5359                 :       91193 : }
    5360                 :             : 
    5361                 :             : /* Return true if string STR contains constraint 'X'.  */
    5362                 :             : static bool
    5363                 :       91193 : contains_X_constraint_p (const char *str)
    5364                 :             : {
    5365                 :       91193 :   int c;
    5366                 :             :   
    5367                 :      338969 :   while ((c = *str))
    5368                 :             :     {
    5369                 :      255523 :       str += CONSTRAINT_LEN (c, str);
    5370                 :      255523 :       if (c == 'X') return true;
    5371                 :             :     }
    5372                 :             :   return false;
    5373                 :             : }
    5374                 :             :   
    5375                 :             : /* Change INSN's scratches into pseudos and save their location.
    5376                 :             :    Return true if we changed any scratch.  */
    5377                 :             : bool
    5378                 :   243762830 : ira_remove_insn_scratches (rtx_insn *insn, bool all_p, FILE *dump_file,
    5379                 :             :                            rtx (*get_reg) (rtx original))
    5380                 :             : {
    5381                 :   243762830 :   int i;
    5382                 :   243762830 :   bool insn_changed_p;
    5383                 :   243762830 :   rtx reg, *loc;
    5384                 :             :    
    5385                 :   243762830 :   extract_insn (insn);
    5386                 :   243762830 :   insn_changed_p = false;
    5387                 :   840711570 :   for (i = 0; i < recog_data.n_operands; i++)
    5388                 :             :     {
    5389                 :   353185910 :       loc = recog_data.operand_loc[i];
    5390                 :   353185910 :       if (GET_CODE (*loc) == SCRATCH && GET_MODE (*loc) != VOIDmode)
    5391                 :             :         {
    5392                 :       98940 :           if (! all_p && contains_X_constraint_p (recog_data.constraints[i]))
    5393                 :        7747 :             continue;
    5394                 :       91193 :           insn_changed_p = true;
    5395                 :       91193 :           *loc = reg = get_reg (*loc);
    5396                 :       91193 :           ira_register_new_scratch_op (insn, i, INSN_CODE (insn));
    5397                 :       91193 :           if (ira_dump_file != NULL)
    5398                 :           0 :             fprintf (dump_file,
    5399                 :             :                      "Removing SCRATCH to p%u in insn #%u (nop %d)\n",
    5400                 :           0 :                      REGNO (reg), INSN_UID (insn), i);
    5401                 :             :         }
    5402                 :             :     }
    5403                 :   243762830 :   return insn_changed_p;
    5404                 :             : }
    5405                 :             : 
    5406                 :             : /* Return new register of the same mode as ORIGINAL.  Used in
    5407                 :             :    remove_scratches.  */
    5408                 :             : static rtx
    5409                 :       83446 : get_scratch_reg (rtx original)
    5410                 :             : {
    5411                 :       83446 :   return gen_reg_rtx (GET_MODE (original));
    5412                 :             : }
    5413                 :             : 
    5414                 :             : /* Change scratches into pseudos and save their location.  Return true
    5415                 :             :    if we changed any scratch.  */
    5416                 :             : static bool
    5417                 :     1421530 : remove_scratches (void)
    5418                 :             : {
    5419                 :     1421530 :   bool change_p = false;
    5420                 :     1421530 :   basic_block bb;
    5421                 :     1421530 :   rtx_insn *insn;
    5422                 :             : 
    5423                 :     1421530 :   scratches.create (get_max_uid ());
    5424                 :     1421530 :   bitmap_initialize (&scratch_bitmap, &reg_obstack);
    5425                 :     1421530 :   bitmap_initialize (&scratch_operand_bitmap, &reg_obstack);
    5426                 :    14657190 :   FOR_EACH_BB_FN (bb, cfun)
    5427                 :   154856910 :     FOR_BB_INSNS (bb, insn)
    5428                 :   141621250 :     if (INSN_P (insn)
    5429                 :   141621250 :         && ira_remove_insn_scratches (insn, false, ira_dump_file, get_scratch_reg))
    5430                 :             :       {
    5431                 :             :         /* Because we might use DF, we need to keep DF info up to date.  */
    5432                 :       82267 :         df_insn_rescan (insn);
    5433                 :       82267 :         change_p = true;
    5434                 :             :       }
    5435                 :     1421530 :   return change_p;
    5436                 :             : }
    5437                 :             : 
    5438                 :             : /* Changes pseudos created by function remove_scratches onto scratches.  */
    5439                 :             : void
    5440                 :     1421530 : ira_restore_scratches (FILE *dump_file)
    5441                 :             : {
    5442                 :     1421530 :   int regno, n;
    5443                 :     1421530 :   unsigned i;
    5444                 :     1421530 :   rtx *op_loc;
    5445                 :     1421530 :   sloc_t loc;
    5446                 :             : 
    5447                 :     1512723 :   for (i = 0; scratches.iterate (i, &loc); i++)
    5448                 :             :     {
    5449                 :             :       /* Ignore already deleted insns.  */
    5450                 :       91193 :       if (NOTE_P (loc->insn)
    5451                 :           0 :           && NOTE_KIND (loc->insn) == NOTE_INSN_DELETED)
    5452                 :           0 :         continue;
    5453                 :       91193 :       extract_insn (loc->insn);
    5454                 :       91193 :       if (loc->icode != INSN_CODE (loc->insn))
    5455                 :             :         {
    5456                 :             :           /* The icode doesn't match, which means the insn has been modified
    5457                 :             :              (e.g. register elimination).  The scratch cannot be restored.  */
    5458                 :           0 :           continue;
    5459                 :             :         }
    5460                 :       91193 :       op_loc = recog_data.operand_loc[loc->nop];
    5461                 :       91193 :       if (REG_P (*op_loc)
    5462                 :       91193 :           && ((regno = REGNO (*op_loc)) >= FIRST_PSEUDO_REGISTER)
    5463                 :      182386 :           && reg_renumber[regno] < 0)
    5464                 :             :         {
    5465                 :             :           /* It should be only case when scratch register with chosen
    5466                 :             :              constraint 'X' did not get memory or hard register.  */
    5467                 :        5262 :           ira_assert (ira_former_scratch_p (regno));
    5468                 :        5262 :           *op_loc = gen_rtx_SCRATCH (GET_MODE (*op_loc));
    5469                 :        5262 :           for (n = 0; n < recog_data.n_dups; n++)
    5470                 :           0 :             *recog_data.dup_loc[n]
    5471                 :           0 :               = *recog_data.operand_loc[(int) recog_data.dup_num[n]];
    5472                 :        5262 :           if (dump_file != NULL)
    5473                 :           0 :             fprintf (dump_file, "Restoring SCRATCH in insn #%u(nop %d)\n",
    5474                 :           0 :                      INSN_UID (loc->insn), loc->nop);
    5475                 :             :         }
    5476                 :             :     }
    5477                 :     1512723 :   for (i = 0; scratches.iterate (i, &loc); i++)
    5478                 :       91193 :     free (loc);
    5479                 :     1421530 :   scratches.release ();
    5480                 :     1421530 :   bitmap_clear (&scratch_bitmap);
    5481                 :     1421530 :   bitmap_clear (&scratch_operand_bitmap);
    5482                 :     1421530 : }
    5483                 :             : 
    5484                 :             : 
    5485                 :             : 
    5486                 :             : /* If the backend knows where to allocate pseudos for hard
    5487                 :             :    register initial values, register these allocations now.  */
    5488                 :             : static void
    5489                 :     1421530 : allocate_initial_values (void)
    5490                 :             : {
    5491                 :     1421530 :   if (targetm.allocate_initial_value)
    5492                 :             :     {
    5493                 :             :       rtx hreg, preg, x;
    5494                 :             :       int i, regno;
    5495                 :             : 
    5496                 :           0 :       for (i = 0; HARD_REGISTER_NUM_P (i); i++)
    5497                 :             :         {
    5498                 :           0 :           if (! initial_value_entry (i, &hreg, &preg))
    5499                 :             :             break;
    5500                 :             : 
    5501                 :           0 :           x = targetm.allocate_initial_value (hreg);
    5502                 :           0 :           regno = REGNO (preg);
    5503                 :           0 :           if (x && REG_N_SETS (regno) <= 1)
    5504                 :             :             {
    5505                 :           0 :               if (MEM_P (x))
    5506                 :           0 :                 reg_equiv_memory_loc (regno) = x;
    5507                 :             :               else
    5508                 :             :                 {
    5509                 :           0 :                   basic_block bb;
    5510                 :           0 :                   int new_regno;
    5511                 :             : 
    5512                 :           0 :                   gcc_assert (REG_P (x));
    5513                 :           0 :                   new_regno = REGNO (x);
    5514                 :           0 :                   reg_renumber[regno] = new_regno;
    5515                 :             :                   /* Poke the regno right into regno_reg_rtx so that even
    5516                 :             :                      fixed regs are accepted.  */
    5517                 :           0 :                   SET_REGNO (preg, new_regno);
    5518                 :             :                   /* Update global register liveness information.  */
    5519                 :           0 :                   FOR_EACH_BB_FN (bb, cfun)
    5520                 :             :                     {
    5521                 :           0 :                       if (REGNO_REG_SET_P (df_get_live_in (bb), regno))
    5522                 :           0 :                         SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
    5523                 :           0 :                       if (REGNO_REG_SET_P (df_get_live_out (bb), regno))
    5524                 :           0 :                         SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
    5525                 :             :                     }
    5526                 :             :                 }
    5527                 :             :             }
    5528                 :             :         }
    5529                 :             : 
    5530                 :           0 :       gcc_checking_assert (! initial_value_entry (FIRST_PSEUDO_REGISTER,
    5531                 :             :                                                   &hreg, &preg));
    5532                 :             :     }
    5533                 :     1421530 : }
    5534                 :             : 
    5535                 :             : 
    5536                 :             : 
    5537                 :             : 
    5538                 :             : /* True when we use LRA instead of reload pass for the current
    5539                 :             :    function.  */
    5540                 :             : bool ira_use_lra_p;
    5541                 :             : 
    5542                 :             : /* True if we have allocno conflicts.  It is false for non-optimized
    5543                 :             :    mode or when the conflict table is too big.  */
    5544                 :             : bool ira_conflicts_p;
    5545                 :             : 
    5546                 :             : /* Saved between IRA and reload.  */
    5547                 :             : static int saved_flag_ira_share_spill_slots;
    5548                 :             : 
    5549                 :             : /* Set to true while in IRA.  */
    5550                 :             : bool ira_in_progress = false;
    5551                 :             : 
    5552                 :             : /* This is the main entry of IRA.  */
    5553                 :             : static void
    5554                 :     1421530 : ira (FILE *f)
    5555                 :             : {
    5556                 :     1421530 :   bool loops_p;
    5557                 :     1421530 :   int ira_max_point_before_emit;
    5558                 :     1421530 :   bool saved_flag_caller_saves = flag_caller_saves;
    5559                 :     1421530 :   enum ira_region saved_flag_ira_region = flag_ira_region;
    5560                 :     1421530 :   basic_block bb;
    5561                 :     1421530 :   edge_iterator ei;
    5562                 :     1421530 :   edge e;
    5563                 :     1421530 :   bool output_jump_reload_p = false;
    5564                 :             :   
    5565                 :     1421530 :   if (ira_use_lra_p)
    5566                 :             :     {
    5567                 :             :       /* First put potential jump output reloads on the output edges
    5568                 :             :          as USE which will be removed at the end of LRA.  The major
    5569                 :             :          goal is actually to create BBs for critical edges for LRA and
    5570                 :             :          populate them later by live info.  In LRA it will be
    5571                 :             :          difficult to do this. */
    5572                 :    14657181 :       FOR_EACH_BB_FN (bb, cfun)
    5573                 :             :         {
    5574                 :    13235651 :           rtx_insn *end = BB_END (bb);
    5575                 :    13235651 :           if (!JUMP_P (end))
    5576                 :     5330230 :             continue;
    5577                 :     7905421 :           extract_insn (end);
    5578                 :    21376528 :           for (int i = 0; i < recog_data.n_operands; i++)
    5579                 :    13471251 :             if (recog_data.operand_type[i] != OP_IN)
    5580                 :             :               {
    5581                 :         144 :                 bool skip_p = false;
    5582                 :         494 :                 FOR_EACH_EDGE (e, ei, bb->succs)
    5583                 :         711 :                   if (EDGE_CRITICAL_P (e)
    5584                 :          11 :                       && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
    5585                 :         361 :                       && (e->flags & EDGE_ABNORMAL))
    5586                 :             :                     {
    5587                 :             :                       skip_p = true;
    5588                 :             :                       break;
    5589                 :             :                     }
    5590                 :         144 :                 if (skip_p)
    5591                 :             :                   break;
    5592                 :         144 :                 output_jump_reload_p = true;
    5593                 :         494 :                 FOR_EACH_EDGE (e, ei, bb->succs)
    5594                 :         711 :                   if (EDGE_CRITICAL_P (e)
    5595                 :         361 :                       && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
    5596                 :             :                     {
    5597                 :          11 :                       start_sequence ();
    5598                 :             :                       /* We need to put some no-op insn here.  We can
    5599                 :             :                          not put a note as commit_edges insertion will
    5600                 :             :                          fail.  */
    5601                 :          11 :                       emit_insn (gen_rtx_USE (VOIDmode, const1_rtx));
    5602                 :          11 :                       rtx_insn *insns = get_insns ();
    5603                 :          11 :                       end_sequence ();
    5604                 :          11 :                       insert_insn_on_edge (insns, e);
    5605                 :             :                     }
    5606                 :             :                 break;
    5607                 :             :               }
    5608                 :             :         }
    5609                 :     1421530 :       if (output_jump_reload_p)
    5610                 :         138 :         commit_edge_insertions ();
    5611                 :             :     }
    5612                 :             : 
    5613                 :     1421530 :   if (flag_ira_verbose < 10)
    5614                 :             :     {
    5615                 :     1421530 :       internal_flag_ira_verbose = flag_ira_verbose;
    5616                 :     1421530 :       ira_dump_file = f;
    5617                 :             :     }
    5618                 :             :   else
    5619                 :             :     {
    5620                 :           0 :       internal_flag_ira_verbose = flag_ira_verbose - 10;
    5621                 :           0 :       ira_dump_file = stderr;
    5622                 :             :     }
    5623                 :             : 
    5624                 :     1421530 :   clear_bb_flags ();
    5625                 :             : 
    5626                 :             :   /* Determine if the current function is a leaf before running IRA
    5627                 :             :      since this can impact optimizations done by the prologue and
    5628                 :             :      epilogue thus changing register elimination offsets.
    5629                 :             :      Other target callbacks may use crtl->is_leaf too, including
    5630                 :             :      SHRINK_WRAPPING_ENABLED, so initialize as early as possible.  */
    5631                 :     1421530 :   crtl->is_leaf = leaf_function_p ();
    5632                 :             : 
    5633                 :             :   /* Perform target specific PIC register initialization.  */
    5634                 :     1421530 :   targetm.init_pic_reg ();
    5635                 :             : 
    5636                 :     1421530 :   ira_conflicts_p = optimize > 0;
    5637                 :             : 
    5638                 :             :   /* Determine the number of pseudos actually requiring coloring.  */
    5639                 :     1421530 :   unsigned int num_used_regs = 0;
    5640                 :    62854009 :   for (unsigned int i = FIRST_PSEUDO_REGISTER; i < DF_REG_SIZE (df); i++)
    5641                 :    61432479 :     if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i))
    5642                 :    28270815 :       num_used_regs++;
    5643                 :             : 
    5644                 :             :   /* If there are too many pseudos and/or basic blocks (e.g. 10K pseudos and
    5645                 :             :      10K blocks or 100K pseudos and 1K blocks) or we have too many function
    5646                 :             :      insns, we will use simplified and faster algorithms in LRA.  */
    5647                 :     1421530 :   lra_simple_p
    5648                 :     1421530 :     = (ira_use_lra_p
    5649                 :     1421530 :        && (num_used_regs >= (1U << 26) / last_basic_block_for_fn (cfun)
    5650                 :             :            /* max uid is a good evaluation of the number of insns as most
    5651                 :             :               optimizations are done on tree-SSA level.  */
    5652                 :     1421525 :            || ((uint64_t) get_max_uid ()
    5653                 :     1421525 :                > (uint64_t) param_ira_simple_lra_insn_threshold * 1000)));
    5654                 :             : 
    5655                 :     1421530 :   if (lra_simple_p)
    5656                 :             :     {
    5657                 :             :       /* It permits to skip live range splitting in LRA.  */
    5658                 :           5 :       flag_caller_saves = false;
    5659                 :             :       /* There is no sense to do regional allocation when we use
    5660                 :             :         simplified LRA.  */
    5661                 :           5 :       flag_ira_region = IRA_REGION_ONE;
    5662                 :           5 :       ira_conflicts_p = false;
    5663                 :             :     }
    5664                 :             : 
    5665                 :             : #ifndef IRA_NO_OBSTACK
    5666                 :             :   gcc_obstack_init (&ira_obstack);
    5667                 :             : #endif
    5668                 :     1421530 :   bitmap_obstack_initialize (&ira_bitmap_obstack);
    5669                 :             : 
    5670                 :             :   /* LRA uses its own infrastructure to handle caller save registers.  */
    5671                 :     1421530 :   if (flag_caller_saves && !ira_use_lra_p)
    5672                 :           0 :     init_caller_save ();
    5673                 :             : 
    5674                 :     1421530 :   setup_prohibited_mode_move_regs ();
    5675                 :     1421530 :   decrease_live_ranges_number ();
    5676                 :     1421530 :   df_note_add_problem ();
    5677                 :             : 
    5678                 :             :   /* DF_LIVE can't be used in the register allocator, too many other
    5679                 :             :      parts of the compiler depend on using the "classic" liveness
    5680                 :             :      interpretation of the DF_LR problem.  See PR38711.
    5681                 :             :      Remove the problem, so that we don't spend time updating it in
    5682                 :             :      any of the df_analyze() calls during IRA/LRA.  */
    5683                 :     1421530 :   if (optimize > 1)
    5684                 :      922997 :     df_remove_problem (df_live);
    5685                 :     1421530 :   gcc_checking_assert (df_live == NULL);
    5686                 :             : 
    5687                 :     1421530 :   if (flag_checking)
    5688                 :     1421510 :     df->changeable_flags |= DF_VERIFY_SCHEDULED;
    5689                 :             : 
    5690                 :     1421530 :   df_analyze ();
    5691                 :             : 
    5692                 :     1421530 :   init_reg_equiv ();
    5693                 :     1421530 :   if (ira_conflicts_p)
    5694                 :             :     {
    5695                 :      996476 :       calculate_dominance_info (CDI_DOMINATORS);
    5696                 :             : 
    5697                 :      996476 :       if (split_live_ranges_for_shrink_wrap ())
    5698                 :       23892 :         df_analyze ();
    5699                 :             : 
    5700                 :      996476 :       free_dominance_info (CDI_DOMINATORS);
    5701                 :             :     }
    5702                 :             : 
    5703                 :     1421530 :   df_clear_flags (DF_NO_INSN_RESCAN);
    5704                 :             : 
    5705                 :     1421530 :   indirect_jump_optimize ();
    5706                 :     1421530 :   if (delete_trivially_dead_insns (get_insns (), max_reg_num ()))
    5707                 :        5140 :     df_analyze ();
    5708                 :             : 
    5709                 :     1421530 :   regstat_init_n_sets_and_refs ();
    5710                 :     1421530 :   regstat_compute_ri ();
    5711                 :             : 
    5712                 :             :   /* If we are not optimizing, then this is the only place before
    5713                 :             :      register allocation where dataflow is done.  And that is needed
    5714                 :             :      to generate these warnings.  */
    5715                 :     1421530 :   if (warn_clobbered)
    5716                 :      133063 :     generate_setjmp_warnings ();
    5717                 :             : 
    5718                 :             :   /* update_equiv_regs can use reg classes of pseudos and they are set up in
    5719                 :             :      register pressure sensitive scheduling and loop invariant motion and in
    5720                 :             :      live range shrinking.  This info can become obsolete if we add new pseudos
    5721                 :             :      since the last set up.  Recalculate it again if the new pseudos were
    5722                 :             :      added.  */
    5723                 :     1421530 :   if (resize_reg_info () && (flag_sched_pressure || flag_live_range_shrinkage
    5724                 :     1421420 :                              || flag_ira_loop_pressure))
    5725                 :          43 :     ira_set_pseudo_classes (true, ira_dump_file);
    5726                 :             : 
    5727                 :     1421530 :   init_alias_analysis ();
    5728                 :     1421530 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    5729                 :     1421530 :   reg_equiv = XCNEWVEC (struct equivalence, max_reg_num ());
    5730                 :     1421530 :   update_equiv_regs_prescan ();
    5731                 :     1421530 :   update_equiv_regs ();
    5732                 :             : 
    5733                 :             :   /* Don't move insns if live range shrinkage or register
    5734                 :             :      pressure-sensitive scheduling were done because it will not
    5735                 :             :      improve allocation but likely worsen insn scheduling.  */
    5736                 :     1421530 :   if (optimize
    5737                 :      996476 :       && !flag_live_range_shrinkage
    5738                 :      996445 :       && !(flag_sched_pressure && flag_schedule_insns))
    5739                 :      996408 :     combine_and_move_insns ();
    5740                 :             : 
    5741                 :             :   /* Gather additional equivalences with memory.  */
    5742                 :     1421530 :   if (optimize && flag_expensive_optimizations)
    5743                 :      922992 :     add_store_equivs ();
    5744                 :             : 
    5745                 :     1421530 :   loop_optimizer_finalize ();
    5746                 :     1421530 :   free_dominance_info (CDI_DOMINATORS);
    5747                 :     1421530 :   end_alias_analysis ();
    5748                 :     1421530 :   free (reg_equiv);
    5749                 :             : 
    5750                 :             :   /* Once max_regno changes, we need to free and re-init/re-compute
    5751                 :             :      some data structures like regstat_n_sets_and_refs and reg_info_p.  */
    5752                 :     1492650 :   auto regstat_recompute_for_max_regno = []() {
    5753                 :       71120 :     regstat_free_n_sets_and_refs ();
    5754                 :       71120 :     regstat_free_ri ();
    5755                 :       71120 :     regstat_init_n_sets_and_refs ();
    5756                 :       71120 :     regstat_compute_ri ();
    5757                 :       71120 :     resize_reg_info ();
    5758                 :       71120 :   };
    5759                 :             : 
    5760                 :     1421530 :   int max_regno_before_rm = max_reg_num ();
    5761                 :     1421530 :   if (ira_use_lra_p && remove_scratches ())
    5762                 :             :     {
    5763                 :       37787 :       ira_expand_reg_equiv ();
    5764                 :             :       /* For now remove_scatches is supposed to create pseudos when it
    5765                 :             :          succeeds, assert this happens all the time.  Once it doesn't
    5766                 :             :          hold, we should guard the regstat recompute for the case
    5767                 :             :          max_regno changes.  */
    5768                 :       37787 :       gcc_assert (max_regno_before_rm != max_reg_num ());
    5769                 :       37787 :       regstat_recompute_for_max_regno ();
    5770                 :             :     }
    5771                 :             : 
    5772                 :     1421530 :   setup_reg_equiv ();
    5773                 :     1421530 :   grow_reg_equivs ();
    5774                 :     1421530 :   setup_reg_equiv_init ();
    5775                 :             : 
    5776                 :     1421530 :   allocated_reg_info_size = max_reg_num ();
    5777                 :             : 
    5778                 :             :   /* It is not worth to do such improvement when we use a simple
    5779                 :             :      allocation because of -O0 usage or because the function is too
    5780                 :             :      big.  */
    5781                 :     1421530 :   if (ira_conflicts_p)
    5782                 :      996476 :     find_moveable_pseudos ();
    5783                 :             : 
    5784                 :     1421530 :   max_regno_before_ira = max_reg_num ();
    5785                 :     1421530 :   ira_setup_eliminable_regset ();
    5786                 :             : 
    5787                 :     1421530 :   ira_overall_cost = ira_reg_cost = ira_mem_cost = 0;
    5788                 :     1421530 :   ira_load_cost = ira_store_cost = ira_shuffle_cost = 0;
    5789                 :     1421530 :   ira_move_loops_num = ira_additional_jumps_num = 0;
    5790                 :             : 
    5791                 :     1421530 :   ira_assert (current_loops == NULL);
    5792                 :     1421530 :   if (flag_ira_region == IRA_REGION_ALL || flag_ira_region == IRA_REGION_MIXED)
    5793                 :      954462 :     loop_optimizer_init (AVOID_CFG_MODIFICATIONS | LOOPS_HAVE_RECORDED_EXITS);
    5794                 :             : 
    5795                 :     1421530 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    5796                 :          95 :     fprintf (ira_dump_file, "Building IRA IR\n");
    5797                 :     1421530 :   loops_p = ira_build ();
    5798                 :             : 
    5799                 :     1421530 :   ira_assert (ira_conflicts_p || !loops_p);
    5800                 :             : 
    5801                 :     1421530 :   saved_flag_ira_share_spill_slots = flag_ira_share_spill_slots;
    5802                 :     1421530 :   if (too_high_register_pressure_p () || cfun->calls_setjmp)
    5803                 :             :     /* It is just wasting compiler's time to pack spilled pseudos into
    5804                 :             :        stack slots in this case -- prohibit it.  We also do this if
    5805                 :             :        there is setjmp call because a variable not modified between
    5806                 :             :        setjmp and longjmp the compiler is required to preserve its
    5807                 :             :        value and sharing slots does not guarantee it.  */
    5808                 :        1240 :     flag_ira_share_spill_slots = false;
    5809                 :             : 
    5810                 :     1421530 :   ira_color ();
    5811                 :             : 
    5812                 :     1421530 :   ira_max_point_before_emit = ira_max_point;
    5813                 :             : 
    5814                 :     1421530 :   ira_initiate_emit_data ();
    5815                 :             : 
    5816                 :     1421530 :   ira_emit (loops_p);
    5817                 :             : 
    5818                 :     1421530 :   max_regno = max_reg_num ();
    5819                 :     1421530 :   if (ira_conflicts_p)
    5820                 :             :     {
    5821                 :      996476 :       if (! loops_p)
    5822                 :             :         {
    5823                 :      962769 :           if (! ira_use_lra_p)
    5824                 :           0 :             ira_initiate_assign ();
    5825                 :             :         }
    5826                 :             :       else
    5827                 :             :         {
    5828                 :       33707 :           expand_reg_info ();
    5829                 :             : 
    5830                 :       33707 :           if (ira_use_lra_p)
    5831                 :             :             {
    5832                 :       33707 :               ira_allocno_t a;
    5833                 :       33707 :               ira_allocno_iterator ai;
    5834                 :             : 
    5835                 :    10813189 :               FOR_EACH_ALLOCNO (a, ai)
    5836                 :             :                 {
    5837                 :    10745775 :                   int old_regno = ALLOCNO_REGNO (a);
    5838                 :    10745775 :                   int new_regno = REGNO (ALLOCNO_EMIT_DATA (a)->reg);
    5839                 :             : 
    5840                 :    10745775 :                   ALLOCNO_REGNO (a) = new_regno;
    5841                 :             : 
    5842                 :    10745775 :                   if (old_regno != new_regno)
    5843                 :     1121304 :                     setup_reg_classes (new_regno, reg_preferred_class (old_regno),
    5844                 :             :                                        reg_alternate_class (old_regno),
    5845                 :             :                                        reg_allocno_class (old_regno));
    5846                 :             :                 }
    5847                 :             :             }
    5848                 :             :           else
    5849                 :             :             {
    5850                 :           0 :               if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    5851                 :           0 :                 fprintf (ira_dump_file, "Flattening IR\n");
    5852                 :           0 :               ira_flattening (max_regno_before_ira, ira_max_point_before_emit);
    5853                 :             :             }
    5854                 :             :           /* New insns were generated: add notes and recalculate live
    5855                 :             :              info.  */
    5856                 :       33707 :           df_analyze ();
    5857                 :             : 
    5858                 :             :           /* ??? Rebuild the loop tree, but why?  Does the loop tree
    5859                 :             :              change if new insns were generated?  Can that be handled
    5860                 :             :              by updating the loop tree incrementally?  */
    5861                 :       33707 :           loop_optimizer_finalize ();
    5862                 :       33707 :           free_dominance_info (CDI_DOMINATORS);
    5863                 :       33707 :           loop_optimizer_init (AVOID_CFG_MODIFICATIONS
    5864                 :             :                                | LOOPS_HAVE_RECORDED_EXITS);
    5865                 :             : 
    5866                 :       33707 :           if (! ira_use_lra_p)
    5867                 :             :             {
    5868                 :           0 :               setup_allocno_assignment_flags ();
    5869                 :           0 :               ira_initiate_assign ();
    5870                 :           0 :               ira_reassign_conflict_allocnos (max_regno);
    5871                 :             :             }
    5872                 :             :         }
    5873                 :             :     }
    5874                 :             : 
    5875                 :     1421530 :   ira_finish_emit_data ();
    5876                 :             : 
    5877                 :     1421530 :   setup_reg_renumber ();
    5878                 :             : 
    5879                 :     1421530 :   calculate_allocation_cost ();
    5880                 :             : 
    5881                 :             : #ifdef ENABLE_IRA_CHECKING
    5882                 :     1421530 :   if (ira_conflicts_p && ! ira_use_lra_p)
    5883                 :             :     /* Opposite to reload pass, LRA does not use any conflict info
    5884                 :             :        from IRA.  We don't rebuild conflict info for LRA (through
    5885                 :             :        ira_flattening call) and cannot use the check here.  We could
    5886                 :             :        rebuild this info for LRA in the check mode but there is a risk
    5887                 :             :        that code generated with the check and without it will be a bit
    5888                 :             :        different.  Calling ira_flattening in any mode would be a
    5889                 :             :        wasting CPU time.  So do not check the allocation for LRA.  */
    5890                 :           0 :     check_allocation ();
    5891                 :             : #endif
    5892                 :             : 
    5893                 :     1421530 :   if (max_regno != max_regno_before_ira)
    5894                 :       33333 :     regstat_recompute_for_max_regno ();
    5895                 :             : 
    5896                 :     1421530 :   overall_cost_before = ira_overall_cost;
    5897                 :     1421530 :   if (! ira_conflicts_p)
    5898                 :      425054 :     grow_reg_equivs ();
    5899                 :             :   else
    5900                 :             :     {
    5901                 :      996476 :       fix_reg_equiv_init ();
    5902                 :             : 
    5903                 :             : #ifdef ENABLE_IRA_CHECKING
    5904                 :      996476 :       print_redundant_copies ();
    5905                 :             : #endif
    5906                 :      996476 :       if (! ira_use_lra_p)
    5907                 :             :         {
    5908                 :           0 :           ira_spilled_reg_stack_slots_num = 0;
    5909                 :           0 :           ira_spilled_reg_stack_slots
    5910                 :           0 :             = ((class ira_spilled_reg_stack_slot *)
    5911                 :           0 :                ira_allocate (max_regno
    5912                 :             :                              * sizeof (class ira_spilled_reg_stack_slot)));
    5913                 :           0 :           memset ((void *)ira_spilled_reg_stack_slots, 0,
    5914                 :           0 :                   max_regno * sizeof (class ira_spilled_reg_stack_slot));
    5915                 :             :         }
    5916                 :             :     }
    5917                 :     1421530 :   allocate_initial_values ();
    5918                 :             : 
    5919                 :             :   /* See comment for find_moveable_pseudos call.  */
    5920                 :     1421530 :   if (ira_conflicts_p)
    5921                 :      996476 :     move_unallocated_pseudos ();
    5922                 :             : 
    5923                 :             :   /* Restore original values.  */
    5924                 :     1421530 :   if (lra_simple_p)
    5925                 :             :     {
    5926                 :           5 :       flag_caller_saves = saved_flag_caller_saves;
    5927                 :           5 :       flag_ira_region = saved_flag_ira_region;
    5928                 :             :     }
    5929                 :     1421530 : }
    5930                 :             : 
    5931                 :             : /* Modify asm goto to avoid further trouble with this insn.  We can
    5932                 :             :    not replace the insn by USE as in other asm insns as we still
    5933                 :             :    need to keep CFG consistency.  */
    5934                 :             : void
    5935                 :          10 : ira_nullify_asm_goto (rtx_insn *insn)
    5936                 :             : {
    5937                 :          10 :   ira_assert (JUMP_P (insn) && INSN_CODE (insn) < 0);
    5938                 :          10 :   rtx tmp = extract_asm_operands (PATTERN (insn));
    5939                 :          10 :   PATTERN (insn) = gen_rtx_ASM_OPERANDS (VOIDmode, ggc_strdup (""), "", 0,
    5940                 :             :                                          rtvec_alloc (0),
    5941                 :             :                                          rtvec_alloc (0),
    5942                 :             :                                          ASM_OPERANDS_LABEL_VEC (tmp),
    5943                 :             :                                          ASM_OPERANDS_SOURCE_LOCATION(tmp));
    5944                 :          10 : }
    5945                 :             : 
    5946                 :             : static void
    5947                 :     1421530 : do_reload (void)
    5948                 :             : {
    5949                 :     1421530 :   basic_block bb;
    5950                 :     1421530 :   bool need_dce;
    5951                 :     1421530 :   unsigned pic_offset_table_regno = INVALID_REGNUM;
    5952                 :             : 
    5953                 :     1421530 :   if (flag_ira_verbose < 10)
    5954                 :     1421530 :     ira_dump_file = dump_file;
    5955                 :             : 
    5956                 :             :   /* If pic_offset_table_rtx is a pseudo register, then keep it so
    5957                 :             :      after reload to avoid possible wrong usages of hard reg assigned
    5958                 :             :      to it.  */
    5959                 :     1421530 :   if (pic_offset_table_rtx
    5960                 :     1421530 :       && REGNO (pic_offset_table_rtx) >= FIRST_PSEUDO_REGISTER)
    5961                 :             :     pic_offset_table_regno = REGNO (pic_offset_table_rtx);
    5962                 :             : 
    5963                 :     1421530 :   timevar_push (TV_RELOAD);
    5964                 :     1421530 :   if (ira_use_lra_p)
    5965                 :             :     {
    5966                 :     1421530 :       if (current_loops != NULL)
    5967                 :             :         {
    5968                 :      954462 :           loop_optimizer_finalize ();
    5969                 :      954462 :           free_dominance_info (CDI_DOMINATORS);
    5970                 :             :         }
    5971                 :    17588882 :       FOR_ALL_BB_FN (bb, cfun)
    5972                 :    16167352 :         bb->loop_father = NULL;
    5973                 :     1421530 :       current_loops = NULL;
    5974                 :             : 
    5975                 :     1421530 :       ira_destroy ();
    5976                 :             : 
    5977                 :     1421530 :       lra (ira_dump_file, internal_flag_ira_verbose);
    5978                 :             :       /* ???!!! Move it before lra () when we use ira_reg_equiv in
    5979                 :             :          LRA.  */
    5980                 :     1421530 :       vec_free (reg_equivs);
    5981                 :     1421530 :       reg_equivs = NULL;
    5982                 :     1421530 :       need_dce = false;
    5983                 :             :     }
    5984                 :             :   else
    5985                 :             :     {
    5986                 :           0 :       df_set_flags (DF_NO_INSN_RESCAN);
    5987                 :           0 :       build_insn_chain ();
    5988                 :             : 
    5989                 :           0 :       need_dce = reload (get_insns (), ira_conflicts_p);
    5990                 :             :     }
    5991                 :             : 
    5992                 :     1421530 :   timevar_pop (TV_RELOAD);
    5993                 :             : 
    5994                 :     1421530 :   timevar_push (TV_IRA);
    5995                 :             : 
    5996                 :     1421530 :   if (ira_conflicts_p && ! ira_use_lra_p)
    5997                 :             :     {
    5998                 :           0 :       ira_free (ira_spilled_reg_stack_slots);
    5999                 :           0 :       ira_finish_assign ();
    6000                 :             :     }
    6001                 :             : 
    6002                 :     1421530 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL
    6003                 :          96 :       && overall_cost_before != ira_overall_cost)
    6004                 :           0 :     fprintf (ira_dump_file, "+++Overall after reload %" PRId64 "\n",
    6005                 :             :              ira_overall_cost);
    6006                 :             : 
    6007                 :     1421530 :   flag_ira_share_spill_slots = saved_flag_ira_share_spill_slots;
    6008                 :             : 
    6009                 :     1421530 :   if (! ira_use_lra_p)
    6010                 :             :     {
    6011                 :           0 :       ira_destroy ();
    6012                 :           0 :       if (current_loops != NULL)
    6013                 :             :         {
    6014                 :           0 :           loop_optimizer_finalize ();
    6015                 :           0 :           free_dominance_info (CDI_DOMINATORS);
    6016                 :             :         }
    6017                 :           0 :       FOR_ALL_BB_FN (bb, cfun)
    6018                 :           0 :         bb->loop_father = NULL;
    6019                 :           0 :       current_loops = NULL;
    6020                 :             :       
    6021                 :           0 :       regstat_free_ri ();
    6022                 :           0 :       regstat_free_n_sets_and_refs ();
    6023                 :             :     }
    6024                 :             : 
    6025                 :     1421530 :   if (optimize)
    6026                 :      996476 :     cleanup_cfg (CLEANUP_EXPENSIVE);
    6027                 :             : 
    6028                 :     1421530 :   finish_reg_equiv ();
    6029                 :             : 
    6030                 :     1421530 :   bitmap_obstack_release (&ira_bitmap_obstack);
    6031                 :             : #ifndef IRA_NO_OBSTACK
    6032                 :             :   obstack_free (&ira_obstack, NULL);
    6033                 :             : #endif
    6034                 :             : 
    6035                 :             :   /* The code after the reload has changed so much that at this point
    6036                 :             :      we might as well just rescan everything.  Note that
    6037                 :             :      df_rescan_all_insns is not going to help here because it does not
    6038                 :             :      touch the artificial uses and defs.  */
    6039                 :     1421530 :   df_finish_pass (true);
    6040                 :     1421530 :   df_scan_alloc (NULL);
    6041                 :     1421530 :   df_scan_blocks ();
    6042                 :             : 
    6043                 :     1421530 :   if (optimize > 1)
    6044                 :             :     {
    6045                 :      922997 :       df_live_add_problem ();
    6046                 :      922997 :       df_live_set_all_dirty ();
    6047                 :             :     }
    6048                 :             : 
    6049                 :     1421530 :   if (optimize)
    6050                 :      996476 :     df_analyze ();
    6051                 :             : 
    6052                 :     1421530 :   if (need_dce && optimize)
    6053                 :           0 :     run_fast_dce ();
    6054                 :             : 
    6055                 :             :   /* Diagnose uses of the hard frame pointer when it is used as a global
    6056                 :             :      register.  Often we can get away with letting the user appropriate
    6057                 :             :      the frame pointer, but we should let them know when code generation
    6058                 :             :      makes that impossible.  */
    6059                 :     1421530 :   if (global_regs[HARD_FRAME_POINTER_REGNUM] && frame_pointer_needed)
    6060                 :             :     {
    6061                 :           2 :       tree decl = global_regs_decl[HARD_FRAME_POINTER_REGNUM];
    6062                 :           2 :       error_at (DECL_SOURCE_LOCATION (current_function_decl),
    6063                 :             :                 "frame pointer required, but reserved");
    6064                 :           2 :       inform (DECL_SOURCE_LOCATION (decl), "for %qD", decl);
    6065                 :             :     }
    6066                 :             : 
    6067                 :             :   /* If we are doing generic stack checking, give a warning if this
    6068                 :             :      function's frame size is larger than we expect.  */
    6069                 :     1421530 :   if (flag_stack_check == GENERIC_STACK_CHECK)
    6070                 :             :     {
    6071                 :          42 :       poly_int64 size = get_frame_size () + STACK_CHECK_FIXED_FRAME_SIZE;
    6072                 :             : 
    6073                 :        3906 :       for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    6074                 :        3864 :         if (df_regs_ever_live_p (i)
    6075                 :         233 :             && !fixed_regs[i]
    6076                 :        4033 :             && !crtl->abi->clobbers_full_reg_p (i))
    6077                 :          80 :           size += UNITS_PER_WORD;
    6078                 :             : 
    6079                 :          42 :       if (constant_lower_bound (size) > STACK_CHECK_MAX_FRAME_SIZE)
    6080                 :           1 :         warning (0, "frame size too large for reliable stack checking");
    6081                 :             :     }
    6082                 :             : 
    6083                 :     1421530 :   if (pic_offset_table_regno != INVALID_REGNUM)
    6084                 :       39373 :     pic_offset_table_rtx = gen_rtx_REG (Pmode, pic_offset_table_regno);
    6085                 :             : 
    6086                 :     1421530 :   timevar_pop (TV_IRA);
    6087                 :     1421530 : }
    6088                 :             : 
    6089                 :             : /* Run the integrated register allocator.  */
    6090                 :             : 
    6091                 :             : namespace {
    6092                 :             : 
    6093                 :             : const pass_data pass_data_ira =
    6094                 :             : {
    6095                 :             :   RTL_PASS, /* type */
    6096                 :             :   "ira", /* name */
    6097                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    6098                 :             :   TV_IRA, /* tv_id */
    6099                 :             :   0, /* properties_required */
    6100                 :             :   0, /* properties_provided */
    6101                 :             :   0, /* properties_destroyed */
    6102                 :             :   0, /* todo_flags_start */
    6103                 :             :   TODO_do_not_ggc_collect, /* todo_flags_finish */
    6104                 :             : };
    6105                 :             : 
    6106                 :             : class pass_ira : public rtl_opt_pass
    6107                 :             : {
    6108                 :             : public:
    6109                 :      273196 :   pass_ira (gcc::context *ctxt)
    6110                 :      546392 :     : rtl_opt_pass (pass_data_ira, ctxt)
    6111                 :             :   {}
    6112                 :             : 
    6113                 :             :   /* opt_pass methods: */
    6114                 :     1421538 :   bool gate (function *) final override
    6115                 :             :     {
    6116                 :     1421538 :       return !targetm.no_register_allocation;
    6117                 :             :     }
    6118                 :     1421530 :   unsigned int execute (function *) final override
    6119                 :             :     {
    6120                 :     1421530 :       ira_in_progress = true;
    6121                 :     1421530 :       ira (dump_file);
    6122                 :     1421530 :       ira_in_progress = false;
    6123                 :     1421530 :       return 0;
    6124                 :             :     }
    6125                 :             : 
    6126                 :             : }; // class pass_ira
    6127                 :             : 
    6128                 :             : } // anon namespace
    6129                 :             : 
    6130                 :             : rtl_opt_pass *
    6131                 :      273196 : make_pass_ira (gcc::context *ctxt)
    6132                 :             : {
    6133                 :      273196 :   return new pass_ira (ctxt);
    6134                 :             : }
    6135                 :             : 
    6136                 :             : namespace {
    6137                 :             : 
    6138                 :             : const pass_data pass_data_reload =
    6139                 :             : {
    6140                 :             :   RTL_PASS, /* type */
    6141                 :             :   "reload", /* name */
    6142                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    6143                 :             :   TV_RELOAD, /* tv_id */
    6144                 :             :   0, /* properties_required */
    6145                 :             :   0, /* properties_provided */
    6146                 :             :   0, /* properties_destroyed */
    6147                 :             :   0, /* todo_flags_start */
    6148                 :             :   0, /* todo_flags_finish */
    6149                 :             : };
    6150                 :             : 
    6151                 :             : class pass_reload : public rtl_opt_pass
    6152                 :             : {
    6153                 :             : public:
    6154                 :      273196 :   pass_reload (gcc::context *ctxt)
    6155                 :      546392 :     : rtl_opt_pass (pass_data_reload, ctxt)
    6156                 :             :   {}
    6157                 :             : 
    6158                 :             :   /* opt_pass methods: */
    6159                 :     1421538 :   bool gate (function *) final override
    6160                 :             :     {
    6161                 :     1421538 :       return !targetm.no_register_allocation;
    6162                 :             :     }
    6163                 :     1421530 :   unsigned int execute (function *) final override
    6164                 :             :     {
    6165                 :     1421530 :       do_reload ();
    6166                 :     1421530 :       return 0;
    6167                 :             :     }
    6168                 :             : 
    6169                 :             : }; // class pass_reload
    6170                 :             : 
    6171                 :             : } // anon namespace
    6172                 :             : 
    6173                 :             : rtl_opt_pass *
    6174                 :      273196 : make_pass_reload (gcc::context *ctxt)
    6175                 :             : {
    6176                 :      273196 :   return new pass_reload (ctxt);
    6177                 :             : }
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.