LCOV - code coverage report
Current view: top level - gcc - ira.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2112 2550 82.8 %
Date: 2020-04-04 11:58:09 Functions: 76 95 80.0 %
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-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Vladimir Makarov <vmakarov@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : /* 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.c) 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.c).
     160                 :            : 
     161                 :            :        * IRA removes low register pressure loops from the regions
     162                 :            :          mostly to speed IRA up (file ira-build.c).
     163                 :            : 
     164                 :            :        * IRA propagates accumulated allocno info from lower region
     165                 :            :          allocnos to corresponding upper region allocnos (file
     166                 :            :          ira-build.c).
     167                 :            : 
     168                 :            :        * IRA creates all caps (file ira-build.c).
     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.c).  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.c).  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.c).  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.c).  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.c).  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.c 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.c.
     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.c).  */
     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                 :     151861 : setup_reg_mode_hard_regset (void)
     445                 :            : {
     446                 :     151861 :   int i, m, hard_regno;
     447                 :            : 
     448                 :   17008400 :   for (m = 0; m < NUM_MACHINE_MODES; m++)
     449                 : 1297960000 :     for (hard_regno = 0; hard_regno < FIRST_PSEUDO_REGISTER; hard_regno++)
     450                 :            :       {
     451                 : 1281100000 :         CLEAR_HARD_REG_SET (ira_reg_mode_hard_regset[hard_regno][m]);
     452                 : 1281100000 :         for (i = hard_regno_nregs (hard_regno, (machine_mode) m) - 1;
     453                 : 3751580000 :              i >= 0; i--)
     454                 : 2470480000 :           if (hard_regno + i < FIRST_PSEUDO_REGISTER)
     455                 : 2470480000 :             SET_HARD_REG_BIT (ira_reg_mode_hard_regset[hard_regno][m],
     456                 :            :                               hard_regno + i);
     457                 :            :       }
     458                 :     151861 : }
     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                 :     151861 : setup_class_hard_regs (void)
     467                 :            : {
     468                 :     151861 :   int cl, i, hard_regno, n;
     469                 :     151861 :   HARD_REG_SET processed_hard_reg_set;
     470                 :            : 
     471                 :     151861 :   ira_assert (SHRT_MAX >= FIRST_PSEUDO_REGISTER);
     472                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     473                 :            :     {
     474                 :    9111660 :       temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     475                 :    4555830 :       CLEAR_HARD_REG_SET (processed_hard_reg_set);
     476                 :  350799000 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     477                 :            :         {
     478                 :  346243000 :           ira_non_ordered_class_hard_regs[cl][i] = -1;
     479                 :  346243000 :           ira_class_hard_reg_index[cl][i] = -1;
     480                 :            :         }
     481                 :  350799000 :       for (n = 0, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     482                 :            :         {
     483                 :            : #ifdef REG_ALLOC_ORDER
     484                 :  346243000 :           hard_regno = reg_alloc_order[i];
     485                 :            : #else
     486                 :            :           hard_regno = i;
     487                 :            : #endif
     488                 :  346243000 :           if (TEST_HARD_REG_BIT (processed_hard_reg_set, hard_regno))
     489                 :   18223300 :             continue;
     490                 :  328020000 :           SET_HARD_REG_BIT (processed_hard_reg_set, hard_regno);
     491                 :  328020000 :           if (! TEST_HARD_REG_BIT (temp_hard_regset, hard_regno))
     492                 :  283396000 :             ira_class_hard_reg_index[cl][hard_regno] = -1;
     493                 :            :           else
     494                 :            :             {
     495                 :   44623900 :               ira_class_hard_reg_index[cl][hard_regno] = n;
     496                 :   44623900 :               ira_class_hard_regs[cl][n++] = hard_regno;
     497                 :            :             }
     498                 :            :         }
     499                 :    4555830 :       ira_class_hard_regs_num[cl] = n;
     500                 :  350799000 :       for (n = 0, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     501                 :  346243000 :         if (TEST_HARD_REG_BIT (temp_hard_regset, i))
     502                 :   44623900 :           ira_non_ordered_class_hard_regs[cl][n++] = i;
     503                 :    4555830 :       ira_assert (ira_class_hard_regs_num[cl] == n);
     504                 :            :     }
     505                 :     151861 : }
     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                 :     151861 : setup_alloc_regs (bool use_hard_frame_p)
     512                 :            : {
     513                 :            : #ifdef ADJUST_REG_ALLOC_ORDER
     514                 :     151861 :   ADJUST_REG_ALLOC_ORDER;
     515                 :            : #endif
     516                 :     151861 :   no_unit_alloc_regs = fixed_nonglobal_reg_set;
     517                 :     151861 :   if (! use_hard_frame_p)
     518                 :      43449 :     add_to_hard_reg_set (&no_unit_alloc_regs, Pmode,
     519                 :            :                          HARD_FRAME_POINTER_REGNUM);
     520                 :     151861 :   setup_class_hard_regs ();
     521                 :     151861 : }
     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                 :     151861 : setup_reg_subclasses (void)
     531                 :            : {
     532                 :     151861 :   int i, j;
     533                 :     151861 :   HARD_REG_SET temp_hard_regset2;
     534                 :            : 
     535                 :    4707690 :   for (i = 0; i < N_REG_CLASSES; i++)
     536                 :  141231000 :     for (j = 0; j < N_REG_CLASSES; j++)
     537                 :  136675000 :       alloc_reg_class_subclasses[i][j] = LIM_REG_CLASSES;
     538                 :            : 
     539                 :    4707690 :   for (i = 0; i < N_REG_CLASSES; i++)
     540                 :            :     {
     541                 :    4555830 :       if (i == (int) NO_REGS)
     542                 :     151861 :         continue;
     543                 :            : 
     544                 :    8807940 :       temp_hard_regset = reg_class_contents[i] & ~no_unit_alloc_regs;
     545                 :    8807940 :       if (hard_reg_set_empty_p (temp_hard_regset))
     546                 :     301957 :         continue;
     547                 :  127162000 :       for (j = 0; j < N_REG_CLASSES; j++)
     548                 :  123060000 :         if (i != j)
     549                 :            :           {
     550                 :            :             enum reg_class *p;
     551                 :            : 
     552                 :  356875000 :             temp_hard_regset2 = reg_class_contents[j] & ~no_unit_alloc_regs;
     553                 :  237917000 :             if (! hard_reg_set_subset_p (temp_hard_regset,
     554                 :            :                                          temp_hard_regset2))
     555                 :   95054700 :               continue;
     556                 :   23903700 :             p = &alloc_reg_class_subclasses[j][0];
     557                 :  199356000 :             while (*p != LIM_REG_CLASSES) p++;
     558                 :   23903700 :             *p = (enum reg_class) i;
     559                 :            :           }
     560                 :            :     }
     561                 :     151861 : }
     562                 :            : 
     563                 :            : 
     564                 :            : 
     565                 :            : /* Set up IRA_MEMORY_MOVE_COST and IRA_MAX_MEMORY_MOVE_COST.  */
     566                 :            : static void
     567                 :     151861 : setup_class_subset_and_memory_move_costs (void)
     568                 :            : {
     569                 :     151861 :   int cl, cl2, mode, cost;
     570                 :     151861 :   HARD_REG_SET temp_hard_regset2;
     571                 :            : 
     572                 :   17008400 :   for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     573                 :   16856600 :     ira_memory_move_cost[mode][NO_REGS][0]
     574                 :   16856600 :       = ira_memory_move_cost[mode][NO_REGS][1] = SHRT_MAX;
     575                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     576                 :            :     {
     577                 :    4555830 :       if (cl != (int) NO_REGS)
     578                 :  493245000 :         for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     579                 :            :           {
     580                 :  977681000 :             ira_max_memory_move_cost[mode][cl][0]
     581                 :  488841000 :               = ira_memory_move_cost[mode][cl][0]
     582                 :  488841000 :               = memory_move_cost ((machine_mode) mode,
     583                 :            :                                   (reg_class_t) cl, false);
     584                 :  977681000 :             ira_max_memory_move_cost[mode][cl][1]
     585                 :  488841000 :               = ira_memory_move_cost[mode][cl][1]
     586                 :  488841000 :               = 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                 :  488841000 :             if (ira_memory_move_cost[mode][NO_REGS][0]
     592                 :  488841000 :                 > ira_memory_move_cost[mode][cl][0])
     593                 :   23775500 :               ira_max_memory_move_cost[mode][NO_REGS][0]
     594                 :   23775500 :                 = ira_memory_move_cost[mode][NO_REGS][0]
     595                 :   23775500 :                 = ira_memory_move_cost[mode][cl][0];
     596                 :  488841000 :             if (ira_memory_move_cost[mode][NO_REGS][1]
     597                 :  488841000 :                 > ira_memory_move_cost[mode][cl][1])
     598                 :   23748300 :               ira_max_memory_move_cost[mode][NO_REGS][1]
     599                 :   23748300 :                 = ira_memory_move_cost[mode][NO_REGS][1]
     600                 :   23748300 :                 = ira_memory_move_cost[mode][cl][1];
     601                 :            :           }
     602                 :            :     }
     603                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     604                 :  141231000 :     for (cl2 = (int) N_REG_CLASSES - 1; cl2 >= 0; cl2--)
     605                 :            :       {
     606                 :  273350000 :         temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     607                 :  273350000 :         temp_hard_regset2 = reg_class_contents[cl2] & ~no_unit_alloc_regs;
     608                 :  136675000 :         ira_class_subset_p[cl][cl2]
     609                 :  136675000 :           = hard_reg_set_subset_p (temp_hard_regset, temp_hard_regset2);
     610                 :  136675000 :         if (! hard_reg_set_empty_p (temp_hard_regset2)
     611                 :  505856000 :             && hard_reg_set_subset_p (reg_class_contents[cl2],
     612                 :            :                                       reg_class_contents[cl]))
     613                 : 3025790000 :           for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     614                 :            :             {
     615                 : 2998780000 :               cost = ira_memory_move_cost[mode][cl2][0];
     616                 : 2998780000 :               if (cost > ira_max_memory_move_cost[mode][cl][0])
     617                 :   68936800 :                 ira_max_memory_move_cost[mode][cl][0] = cost;
     618                 : 2998780000 :               cost = ira_memory_move_cost[mode][cl2][1];
     619                 : 2998780000 :               if (cost > ira_max_memory_move_cost[mode][cl][1])
     620                 :   68930800 :                 ira_max_memory_move_cost[mode][cl][1] = cost;
     621                 :            :             }
     622                 :            :       }
     623                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
     624                 :  510253000 :     for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
     625                 :            :       {
     626                 :  505697000 :         ira_memory_move_cost[mode][cl][0]
     627                 :  505697000 :           = ira_max_memory_move_cost[mode][cl][0];
     628                 :  505697000 :         ira_memory_move_cost[mode][cl][1]
     629                 :  505697000 :           = ira_max_memory_move_cost[mode][cl][1];
     630                 :            :       }
     631                 :     151861 :   setup_reg_subclasses ();
     632                 :     151861 : }
     633                 :            : 
     634                 :            : 
     635                 :            : 
     636                 :            : /* Define the following macro if allocation through malloc if
     637                 :            :    preferable.  */
     638                 :            : #define IRA_NO_OBSTACK
     639                 :            : 
     640                 :            : #ifndef IRA_NO_OBSTACK
     641                 :            : /* Obstack used for storing all dynamic data (except bitmaps) of the
     642                 :            :    IRA.  */
     643                 :            : static struct obstack ira_obstack;
     644                 :            : #endif
     645                 :            : 
     646                 :            : /* Obstack used for storing all bitmaps of the IRA.  */
     647                 :            : static struct bitmap_obstack ira_bitmap_obstack;
     648                 :            : 
     649                 :            : /* Allocate memory of size LEN for IRA data.  */
     650                 :            : void *
     651                 :  134218000 : ira_allocate (size_t len)
     652                 :            : {
     653                 :  134218000 :   void *res;
     654                 :            : 
     655                 :            : #ifndef IRA_NO_OBSTACK
     656                 :            :   res = obstack_alloc (&ira_obstack, len);
     657                 :            : #else
     658                 :  134218000 :   res = xmalloc (len);
     659                 :            : #endif
     660                 :  134218000 :   return res;
     661                 :            : }
     662                 :            : 
     663                 :            : /* Free memory ADDR allocated for IRA data.  */
     664                 :            : void
     665                 :  134218000 : ira_free (void *addr ATTRIBUTE_UNUSED)
     666                 :            : {
     667                 :            : #ifndef IRA_NO_OBSTACK
     668                 :            :   /* do nothing */
     669                 :            : #else
     670                 :  134218000 :   free (addr);
     671                 :            : #endif
     672                 :  134218000 : }
     673                 :            : 
     674                 :            : 
     675                 :            : /* Allocate and returns bitmap for IRA.  */
     676                 :            : bitmap
     677                 :    6557910 : ira_allocate_bitmap (void)
     678                 :            : {
     679                 :    6557910 :   return BITMAP_ALLOC (&ira_bitmap_obstack);
     680                 :            : }
     681                 :            : 
     682                 :            : /* Free bitmap B allocated for IRA.  */
     683                 :            : void
     684                 :    6557910 : ira_free_bitmap (bitmap b ATTRIBUTE_UNUSED)
     685                 :            : {
     686                 :            :   /* do nothing */
     687                 :    6557910 : }
     688                 :            : 
     689                 :            : 
     690                 :            : 
     691                 :            : /* Output information about allocation of all allocnos (except for
     692                 :            :    caps) into file F.  */
     693                 :            : void
     694                 :        102 : ira_print_disposition (FILE *f)
     695                 :            : {
     696                 :        102 :   int i, n, max_regno;
     697                 :        102 :   ira_allocno_t a;
     698                 :        102 :   basic_block bb;
     699                 :            : 
     700                 :        102 :   fprintf (f, "Disposition:");
     701                 :        102 :   max_regno = max_reg_num ();
     702                 :       1979 :   for (n = 0, i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
     703                 :       1877 :     for (a = ira_regno_allocno_map[i];
     704                 :       2567 :          a != NULL;
     705                 :        690 :          a = ALLOCNO_NEXT_REGNO_ALLOCNO (a))
     706                 :            :       {
     707                 :        690 :         if (n % 4 == 0)
     708                 :        204 :           fprintf (f, "\n");
     709                 :        690 :         n++;
     710                 :        690 :         fprintf (f, " %4d:r%-4d", ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
     711                 :        690 :         if ((bb = ALLOCNO_LOOP_TREE_NODE (a)->bb) != NULL)
     712                 :          0 :           fprintf (f, "b%-3d", bb->index);
     713                 :            :         else
     714                 :        690 :           fprintf (f, "l%-3d", ALLOCNO_LOOP_TREE_NODE (a)->loop_num);
     715                 :        690 :         if (ALLOCNO_HARD_REGNO (a) >= 0)
     716                 :        657 :           fprintf (f, " %3d", ALLOCNO_HARD_REGNO (a));
     717                 :            :         else
     718                 :         33 :           fprintf (f, " mem");
     719                 :            :       }
     720                 :        102 :   fprintf (f, "\n");
     721                 :        102 : }
     722                 :            : 
     723                 :            : /* Outputs information about allocation of all allocnos into
     724                 :            :    stderr.  */
     725                 :            : void
     726                 :          0 : ira_debug_disposition (void)
     727                 :            : {
     728                 :          0 :   ira_print_disposition (stderr);
     729                 :          0 : }
     730                 :            : 
     731                 :            : 
     732                 :            : 
     733                 :            : /* Set up ira_stack_reg_pressure_class which is the biggest pressure
     734                 :            :    register class containing stack registers or NO_REGS if there are
     735                 :            :    no stack registers.  To find this class, we iterate through all
     736                 :            :    register pressure classes and choose the first register pressure
     737                 :            :    class containing all the stack registers and having the biggest
     738                 :            :    size.  */
     739                 :            : static void
     740                 :     151861 : setup_stack_reg_pressure_class (void)
     741                 :            : {
     742                 :     151861 :   ira_stack_reg_pressure_class = NO_REGS;
     743                 :            : #ifdef STACK_REGS
     744                 :     151861 :   {
     745                 :     151861 :     int i, best, size;
     746                 :     151861 :     enum reg_class cl;
     747                 :     151861 :     HARD_REG_SET temp_hard_regset2;
     748                 :            : 
     749                 :     151861 :     CLEAR_HARD_REG_SET (temp_hard_regset);
     750                 :    1366750 :     for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
     751                 :    1214890 :       SET_HARD_REG_BIT (temp_hard_regset, i);
     752                 :            :     best = 0;
     753                 :     760006 :     for (i = 0; i < ira_pressure_classes_num; i++)
     754                 :            :       {
     755                 :     608145 :         cl = ira_pressure_classes[i];
     756                 :     608145 :         temp_hard_regset2 = temp_hard_regset & reg_class_contents[cl];
     757                 :     608145 :         size = hard_reg_set_size (temp_hard_regset2);
     758                 :     608145 :         if (best < size)
     759                 :            :           {
     760                 :     151633 :             best = size;
     761                 :     151633 :             ira_stack_reg_pressure_class = cl;
     762                 :            :           }
     763                 :            :       }
     764                 :            :   }
     765                 :            : #endif
     766                 :     151861 : }
     767                 :            : 
     768                 :            : /* Find pressure classes which are register classes for which we
     769                 :            :    calculate register pressure in IRA, register pressure sensitive
     770                 :            :    insn scheduling, and register pressure sensitive loop invariant
     771                 :            :    motion.
     772                 :            : 
     773                 :            :    To make register pressure calculation easy, we always use
     774                 :            :    non-intersected register pressure classes.  A move of hard
     775                 :            :    registers from one register pressure class is not more expensive
     776                 :            :    than load and store of the hard registers.  Most likely an allocno
     777                 :            :    class will be a subset of a register pressure class and in many
     778                 :            :    cases a register pressure class.  That makes usage of register
     779                 :            :    pressure classes a good approximation to find a high register
     780                 :            :    pressure.  */
     781                 :            : static void
     782                 :     151861 : setup_pressure_classes (void)
     783                 :            : {
     784                 :     151861 :   int cost, i, n, curr;
     785                 :     151861 :   int cl, cl2;
     786                 :     151861 :   enum reg_class pressure_classes[N_REG_CLASSES];
     787                 :     151861 :   int m;
     788                 :     151861 :   HARD_REG_SET temp_hard_regset2;
     789                 :     151861 :   bool insert_p;
     790                 :            : 
     791                 :     151861 :   if (targetm.compute_pressure_classes)
     792                 :          0 :     n = targetm.compute_pressure_classes (pressure_classes);
     793                 :            :   else
     794                 :            :     { 
     795                 :            :       n = 0;
     796                 :    4707690 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
     797                 :            :         {
     798                 :    4555830 :           if (ira_class_hard_regs_num[cl] == 0)
     799                 :     453818 :             continue;
     800                 :    4102010 :           if (ira_class_hard_regs_num[cl] != 1
     801                 :            :               /* A register class without subclasses may contain a few
     802                 :            :                  hard registers and movement between them is costly
     803                 :            :                  (e.g. SPARC FPCC registers).  We still should consider it
     804                 :            :                  as a candidate for a pressure class.  */
     805                 :    2736280 :               && alloc_reg_class_subclasses[cl][0] < cl)
     806                 :            :             {
     807                 :            :               /* Check that the moves between any hard registers of the
     808                 :            :                  current class are not more expensive for a legal mode
     809                 :            :                  than load/store of the hard registers of the current
     810                 :            :                  class.  Such class is a potential candidate to be a
     811                 :            :                  register pressure class.  */
     812                 :  119352000 :               for (m = 0; m < NUM_MACHINE_MODES; m++)
     813                 :            :                 {
     814                 :  118593000 :                   temp_hard_regset
     815                 :  118593000 :                     = (reg_class_contents[cl]
     816                 :  237186000 :                        & ~(no_unit_alloc_regs
     817                 :  355778000 :                            | ira_prohibited_class_mode_regs[cl][m]));
     818                 :  237186000 :                   if (hard_reg_set_empty_p (temp_hard_regset))
     819                 :   94190400 :                     continue;
     820                 :   24402400 :                   ira_init_register_move_cost_if_necessary ((machine_mode) m);
     821                 :   24402400 :                   cost = ira_register_move_cost[m][cl][cl];
     822                 :   24402400 :                   if (cost <= ira_max_memory_move_cost[m][cl][1]
     823                 :   22578600 :                       || cost <= ira_max_memory_move_cost[m][cl][0])
     824                 :            :                     break;
     825                 :            :                 }
     826                 :    2582930 :               if (m >= NUM_MACHINE_MODES)
     827                 :     759078 :                 continue;
     828                 :            :             }
     829                 :    3342930 :           curr = 0;
     830                 :    3342930 :           insert_p = true;
     831                 :    6685870 :           temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
     832                 :            :           /* Remove so far added pressure classes which are subset of the
     833                 :            :              current candidate class.  Prefer GENERAL_REGS as a pressure
     834                 :            :              register class to another class containing the same
     835                 :            :              allocatable hard registers.  We do this because machine
     836                 :            :              dependent cost hooks might give wrong costs for the latter
     837                 :            :              class but always give the right cost for the former class
     838                 :            :              (GENERAL_REGS).  */
     839                 :   12130200 :           for (i = 0; i < n; i++)
     840                 :            :             {
     841                 :    8787260 :               cl2 = pressure_classes[i];
     842                 :    8787260 :               temp_hard_regset2 = (reg_class_contents[cl2]
     843                 :   17574500 :                                    & ~no_unit_alloc_regs);
     844                 :    8787260 :               if (hard_reg_set_subset_p (temp_hard_regset, temp_hard_regset2)
     845                 :    9286310 :                   && (temp_hard_regset != temp_hard_regset2
     846                 :     308680 :                       || cl2 == (int) GENERAL_REGS))
     847                 :            :                 {
     848                 :     190371 :                   pressure_classes[curr++] = (enum reg_class) cl2;
     849                 :     190371 :                   insert_p = false;
     850                 :     190371 :                   continue;
     851                 :            :                 }
     852                 :   25790700 :               if (hard_reg_set_subset_p (temp_hard_regset2, temp_hard_regset)
     853                 :   11141300 :                   && (temp_hard_regset2 != temp_hard_regset
     854                 :     308680 :                       || cl == (int) GENERAL_REGS))
     855                 :    2387600 :                 continue;
     856                 :   18627900 :               if (temp_hard_regset2 == temp_hard_regset)
     857                 :     156819 :                 insert_p = false;
     858                 :    6209290 :               pressure_classes[curr++] = (enum reg_class) cl2;
     859                 :            :             }
     860                 :            :           /* If the current candidate is a subset of a so far added
     861                 :            :              pressure class, don't add it to the list of the pressure
     862                 :            :              classes.  */
     863                 :    3342930 :           if (insert_p)
     864                 :    2995740 :             pressure_classes[curr++] = (enum reg_class) cl;
     865                 :            :           n = curr;
     866                 :            :         }
     867                 :            :     }
     868                 :            : #ifdef ENABLE_IRA_CHECKING
     869                 :     151861 :   {
     870                 :     151861 :     HARD_REG_SET ignore_hard_regs;
     871                 :            : 
     872                 :            :     /* Check pressure classes correctness: here we check that hard
     873                 :            :        registers from all register pressure classes contains all hard
     874                 :            :        registers available for the allocation.  */
     875                 :     151861 :     CLEAR_HARD_REG_SET (temp_hard_regset);
     876                 :     455583 :     CLEAR_HARD_REG_SET (temp_hard_regset2);
     877                 :     151861 :     ignore_hard_regs = no_unit_alloc_regs;
     878                 :    4707690 :     for (cl = 0; cl < LIM_REG_CLASSES; cl++)
     879                 :            :       {
     880                 :            :         /* For some targets (like MIPS with MD_REGS), there are some
     881                 :            :            classes with hard registers available for allocation but
     882                 :            :            not able to hold value of any mode.  */
     883                 :  131019000 :         for (m = 0; m < NUM_MACHINE_MODES; m++)
     884                 :  130565000 :           if (contains_reg_of_mode[cl][m])
     885                 :            :             break;
     886                 :    4555830 :         if (m >= NUM_MACHINE_MODES)
     887                 :            :           {
     888                 :     453818 :             ignore_hard_regs |= reg_class_contents[cl];
     889                 :     453818 :             continue;
     890                 :            :           }
     891                 :   19020600 :         for (i = 0; i < n; i++)
     892                 :   15526800 :           if ((int) pressure_classes[i] == cl)
     893                 :            :             break;
     894                 :    4102010 :         temp_hard_regset2 |= reg_class_contents[cl];
     895                 :    4102010 :         if (i < n)
     896                 :    5772120 :           temp_hard_regset |= reg_class_contents[cl];
     897                 :            :       }
     898                 :   11693300 :     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     899                 :            :       /* Some targets (like SPARC with ICC reg) have allocatable regs
     900                 :            :          for which no reg class is defined.  */
     901                 :   11541400 :       if (REGNO_REG_CLASS (i) == NO_REGS)
     902                 :   11541400 :         SET_HARD_REG_BIT (ignore_hard_regs, i);
     903                 :     455583 :     temp_hard_regset &= ~ignore_hard_regs;
     904                 :     303722 :     temp_hard_regset2 &= ~ignore_hard_regs;
     905                 :     303722 :     ira_assert (hard_reg_set_subset_p (temp_hard_regset2, temp_hard_regset));
     906                 :            :   }
     907                 :            : #endif
     908                 :     151861 :   ira_pressure_classes_num = 0;
     909                 :     760006 :   for (i = 0; i < n; i++)
     910                 :            :     {
     911                 :     608145 :       cl = (int) pressure_classes[i];
     912                 :     608145 :       ira_reg_pressure_class_p[cl] = true;
     913                 :     608145 :       ira_pressure_classes[ira_pressure_classes_num++] = (enum reg_class) cl;
     914                 :            :     }
     915                 :     151861 :   setup_stack_reg_pressure_class ();
     916                 :     151861 : }
     917                 :            : 
     918                 :            : /* Set up IRA_UNIFORM_CLASS_P.  Uniform class is a register class
     919                 :            :    whose register move cost between any registers of the class is the
     920                 :            :    same as for all its subclasses.  We use the data to speed up the
     921                 :            :    2nd pass of calculations of allocno costs.  */
     922                 :            : static void
     923                 :     151861 : setup_uniform_class_p (void)
     924                 :            : {
     925                 :     151861 :   int i, cl, cl2, m;
     926                 :            : 
     927                 :    4707690 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
     928                 :            :     {
     929                 :    4555830 :       ira_uniform_class_p[cl] = false;
     930                 :    4555830 :       if (ira_class_hard_regs_num[cl] == 0)
     931                 :     453818 :         continue;
     932                 :            :       /* We cannot use alloc_reg_class_subclasses here because move
     933                 :            :          cost hooks does not take into account that some registers are
     934                 :            :          unavailable for the subtarget.  E.g. for i686, INT_SSE_REGS
     935                 :            :          is element of alloc_reg_class_subclasses for GENERAL_REGS
     936                 :            :          because SSE regs are unavailable.  */
     937                 :   13052100 :       for (i = 0; (cl2 = reg_class_subclasses[cl][i]) != LIM_REG_CLASSES; i++)
     938                 :            :         {
     939                 :    9709180 :           if (ira_class_hard_regs_num[cl2] == 0)
     940                 :         89 :             continue;
     941                 : 1018790000 :           for (m = 0; m < NUM_MACHINE_MODES; m++)
     942                 : 1009840000 :             if (contains_reg_of_mode[cl][m] && contains_reg_of_mode[cl2][m])
     943                 :            :               {
     944                 :  166329000 :                 ira_init_register_move_cost_if_necessary ((machine_mode) m);
     945                 :  166329000 :                 if (ira_register_move_cost[m][cl][cl]
     946                 :  166329000 :                     != ira_register_move_cost[m][cl2][cl2])
     947                 :            :                   break;
     948                 :            :               }
     949                 :    9709090 :           if (m < NUM_MACHINE_MODES)
     950                 :            :             break;
     951                 :            :         }
     952                 :    4102010 :       if (cl2 == LIM_REG_CLASSES)
     953                 :    3342930 :         ira_uniform_class_p[cl] = true;
     954                 :            :     }
     955                 :     151861 : }
     956                 :            : 
     957                 :            : /* Set up IRA_ALLOCNO_CLASSES, IRA_ALLOCNO_CLASSES_NUM,
     958                 :            :    IRA_IMPORTANT_CLASSES, and IRA_IMPORTANT_CLASSES_NUM.
     959                 :            : 
     960                 :            :    Target may have many subtargets and not all target hard registers can
     961                 :            :    be used for allocation, e.g. x86 port in 32-bit mode cannot use
     962                 :            :    hard registers introduced in x86-64 like r8-r15).  Some classes
     963                 :            :    might have the same allocatable hard registers, e.g.  INDEX_REGS
     964                 :            :    and GENERAL_REGS in x86 port in 32-bit mode.  To decrease different
     965                 :            :    calculations efforts we introduce allocno classes which contain
     966                 :            :    unique non-empty sets of allocatable hard-registers.
     967                 :            : 
     968                 :            :    Pseudo class cost calculation in ira-costs.c is very expensive.
     969                 :            :    Therefore we are trying to decrease number of classes involved in
     970                 :            :    such calculation.  Register classes used in the cost calculation
     971                 :            :    are called important classes.  They are allocno classes and other
     972                 :            :    non-empty classes whose allocatable hard register sets are inside
     973                 :            :    of an allocno class hard register set.  From the first sight, it
     974                 :            :    looks like that they are just allocno classes.  It is not true.  In
     975                 :            :    example of x86-port in 32-bit mode, allocno classes will contain
     976                 :            :    GENERAL_REGS but not LEGACY_REGS (because allocatable hard
     977                 :            :    registers are the same for the both classes).  The important
     978                 :            :    classes will contain GENERAL_REGS and LEGACY_REGS.  It is done
     979                 :            :    because a machine description insn constraint may refers for
     980                 :            :    LEGACY_REGS and code in ira-costs.c is mostly base on investigation
     981                 :            :    of the insn constraints.  */
     982                 :            : static void
     983                 :     151861 : setup_allocno_and_important_classes (void)
     984                 :            : {
     985                 :     151861 :   int i, j, n, cl;
     986                 :     151861 :   bool set_p;
     987                 :     151861 :   HARD_REG_SET temp_hard_regset2;
     988                 :     151861 :   static enum reg_class classes[LIM_REG_CLASSES + 1];
     989                 :            : 
     990                 :     151861 :   n = 0;
     991                 :            :   /* Collect classes which contain unique sets of allocatable hard
     992                 :            :      registers.  Prefer GENERAL_REGS to other classes containing the
     993                 :            :      same set of hard registers.  */
     994                 :    4707690 :   for (i = 0; i < LIM_REG_CLASSES; i++)
     995                 :            :     {
     996                 :    9111660 :       temp_hard_regset = reg_class_contents[i] & ~no_unit_alloc_regs;
     997                 :   58607700 :       for (j = 0; j < n; j++)
     998                 :            :         {
     999                 :   54666100 :           cl = classes[j];
    1000                 :  109332000 :           temp_hard_regset2 = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1001                 :  109332000 :           if (temp_hard_regset == temp_hard_regset2)
    1002                 :            :             break;
    1003                 :            :         }
    1004                 :    4555830 :       if (j >= n || targetm.additional_allocno_class_p (i))
    1005                 :    3941580 :         classes[n++] = (enum reg_class) i;
    1006                 :     614245 :       else if (i == GENERAL_REGS)
    1007                 :            :         /* Prefer general regs.  For i386 example, it means that
    1008                 :            :            we prefer GENERAL_REGS over INDEX_REGS or LEGACY_REGS
    1009                 :            :            (all of them consists of the same available hard
    1010                 :            :            registers).  */
    1011                 :     151861 :         classes[j] = (enum reg_class) i;
    1012                 :            :     }
    1013                 :     151861 :   classes[n] = LIM_REG_CLASSES;
    1014                 :            : 
    1015                 :            :   /* Set up classes which can be used for allocnos as classes
    1016                 :            :      containing non-empty unique sets of allocatable hard
    1017                 :            :      registers.  */
    1018                 :     151861 :   ira_allocno_classes_num = 0;
    1019                 :    4093450 :   for (i = 0; (cl = classes[i]) != LIM_REG_CLASSES; i++)
    1020                 :    3941580 :     if (ira_class_hard_regs_num[cl] > 0)
    1021                 :    3789720 :       ira_allocno_classes[ira_allocno_classes_num++] = (enum reg_class) cl;
    1022                 :     151861 :   ira_important_classes_num = 0;
    1023                 :            :   /* Add non-allocno classes containing to non-empty set of
    1024                 :            :      allocatable hard regs.  */
    1025                 :    4707690 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1026                 :    4555830 :     if (ira_class_hard_regs_num[cl] > 0)
    1027                 :            :       {
    1028                 :   12306000 :         temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1029                 :    4102010 :         set_p = false;
    1030                 :   57293600 :         for (j = 0; j < ira_allocno_classes_num; j++)
    1031                 :            :           {
    1032                 :   56981300 :             temp_hard_regset2 = (reg_class_contents[ira_allocno_classes[j]]
    1033                 :  170944000 :                                  & ~no_unit_alloc_regs);
    1034                 :   56981300 :             if ((enum reg_class) cl == ira_allocno_classes[j])
    1035                 :            :               break;
    1036                 :  159575000 :             else if (hard_reg_set_subset_p (temp_hard_regset,
    1037                 :            :                                             temp_hard_regset2))
    1038                 :    1732570 :               set_p = true;
    1039                 :            :           }
    1040                 :    4102010 :         if (set_p && j >= ira_allocno_classes_num)
    1041                 :     312288 :           ira_important_classes[ira_important_classes_num++]
    1042                 :     312288 :             = (enum reg_class) cl;
    1043                 :            :       }
    1044                 :            :   /* Now add allocno classes to the important classes.  */
    1045                 :    3941580 :   for (j = 0; j < ira_allocno_classes_num; j++)
    1046                 :    3789720 :     ira_important_classes[ira_important_classes_num++]
    1047                 :    3789720 :       = ira_allocno_classes[j];
    1048                 :    4707690 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1049                 :            :     {
    1050                 :    4555830 :       ira_reg_allocno_class_p[cl] = false;
    1051                 :    4555830 :       ira_reg_pressure_class_p[cl] = false;
    1052                 :            :     }
    1053                 :    3941580 :   for (j = 0; j < ira_allocno_classes_num; j++)
    1054                 :    3789720 :     ira_reg_allocno_class_p[ira_allocno_classes[j]] = true;
    1055                 :     151861 :   setup_pressure_classes ();
    1056                 :     151861 :   setup_uniform_class_p ();
    1057                 :     151861 : }
    1058                 :            : 
    1059                 :            : /* Setup translation in CLASS_TRANSLATE of all classes into a class
    1060                 :            :    given by array CLASSES of length CLASSES_NUM.  The function is used
    1061                 :            :    make translation any reg class to an allocno class or to an
    1062                 :            :    pressure class.  This translation is necessary for some
    1063                 :            :    calculations when we can use only allocno or pressure classes and
    1064                 :            :    such translation represents an approximate representation of all
    1065                 :            :    classes.
    1066                 :            : 
    1067                 :            :    The translation in case when allocatable hard register set of a
    1068                 :            :    given class is subset of allocatable hard register set of a class
    1069                 :            :    in CLASSES is pretty simple.  We use smallest classes from CLASSES
    1070                 :            :    containing a given class.  If allocatable hard register set of a
    1071                 :            :    given class is not a subset of any corresponding set of a class
    1072                 :            :    from CLASSES, we use the cheapest (with load/store point of view)
    1073                 :            :    class from CLASSES whose set intersects with given class set.  */
    1074                 :            : static void
    1075                 :     303722 : setup_class_translate_array (enum reg_class *class_translate,
    1076                 :            :                              int classes_num, enum reg_class *classes)
    1077                 :            : {
    1078                 :     303722 :   int cl, mode;
    1079                 :     303722 :   enum reg_class aclass, best_class, *cl_ptr;
    1080                 :     303722 :   int i, cost, min_cost, best_cost;
    1081                 :            : 
    1082                 :    9415380 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1083                 :    9111660 :     class_translate[cl] = NO_REGS;
    1084                 :            : 
    1085                 :    4701590 :   for (i = 0; i < classes_num; i++)
    1086                 :            :     {
    1087                 :    4397870 :       aclass = classes[i];
    1088                 :   28476200 :       for (cl_ptr = &alloc_reg_class_subclasses[aclass][0];
    1089                 :   28476200 :            (cl = *cl_ptr) != LIM_REG_CLASSES;
    1090                 :            :            cl_ptr++)
    1091                 :   24078300 :         if (class_translate[cl] == NO_REGS)
    1092                 :    3239010 :           class_translate[cl] = aclass;
    1093                 :    4397870 :       class_translate[aclass] = aclass;
    1094                 :            :     }
    1095                 :            :   /* For classes which are not fully covered by one of given classes
    1096                 :            :      (in other words covered by more one given class), use the
    1097                 :            :      cheapest class.  */
    1098                 :    9415380 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1099                 :            :     {
    1100                 :    9111660 :       if (cl == NO_REGS || class_translate[cl] != NO_REGS)
    1101                 :    7750230 :         continue;
    1102                 :            :       best_class = NO_REGS;
    1103                 :            :       best_cost = INT_MAX;
    1104                 :   13064800 :       for (i = 0; i < classes_num; i++)
    1105                 :            :         {
    1106                 :   11703300 :           aclass = classes[i];
    1107                 :   23406700 :           temp_hard_regset = (reg_class_contents[aclass]
    1108                 :   11703300 :                               & reg_class_contents[cl]
    1109                 :   23406700 :                               & ~no_unit_alloc_regs);
    1110                 :   23406700 :           if (! hard_reg_set_empty_p (temp_hard_regset))
    1111                 :            :             {
    1112                 :            :               min_cost = INT_MAX;
    1113                 :  220750000 :               for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
    1114                 :            :                 {
    1115                 :  218779000 :                   cost = (ira_memory_move_cost[mode][aclass][0]
    1116                 :  218779000 :                           + ira_memory_move_cost[mode][aclass][1]);
    1117                 :  218779000 :                   if (min_cost > cost)
    1118                 :            :                     min_cost = cost;
    1119                 :            :                 }
    1120                 :    1970980 :               if (best_class == NO_REGS || best_cost > min_cost)
    1121                 :            :                 {
    1122                 :     758009 :                   best_class = aclass;
    1123                 :     758009 :                   best_cost = min_cost;
    1124                 :            :                 }
    1125                 :            :             }
    1126                 :            :         }
    1127                 :    1361430 :       class_translate[cl] = best_class;
    1128                 :            :     }
    1129                 :     303722 : }
    1130                 :            : 
    1131                 :            : /* Set up array IRA_ALLOCNO_CLASS_TRANSLATE and
    1132                 :            :    IRA_PRESSURE_CLASS_TRANSLATE.  */
    1133                 :            : static void
    1134                 :     151861 : setup_class_translate (void)
    1135                 :            : {
    1136                 :     151861 :   setup_class_translate_array (ira_allocno_class_translate,
    1137                 :     151861 :                                ira_allocno_classes_num, ira_allocno_classes);
    1138                 :     151861 :   setup_class_translate_array (ira_pressure_class_translate,
    1139                 :     151861 :                                ira_pressure_classes_num, ira_pressure_classes);
    1140                 :     151861 : }
    1141                 :            : 
    1142                 :            : /* Order numbers of allocno classes in original target allocno class
    1143                 :            :    array, -1 for non-allocno classes.  */
    1144                 :            : static int allocno_class_order[N_REG_CLASSES];
    1145                 :            : 
    1146                 :            : /* The function used to sort the important classes.  */
    1147                 :            : static int
    1148                 :  104937000 : comp_reg_classes_func (const void *v1p, const void *v2p)
    1149                 :            : {
    1150                 :  104937000 :   enum reg_class cl1 = *(const enum reg_class *) v1p;
    1151                 :  104937000 :   enum reg_class cl2 = *(const enum reg_class *) v2p;
    1152                 :  104937000 :   enum reg_class tcl1, tcl2;
    1153                 :  104937000 :   int diff;
    1154                 :            : 
    1155                 :  104937000 :   tcl1 = ira_allocno_class_translate[cl1];
    1156                 :  104937000 :   tcl2 = ira_allocno_class_translate[cl2];
    1157                 :  104937000 :   if (tcl1 != NO_REGS && tcl2 != NO_REGS
    1158                 :  104937000 :       && (diff = allocno_class_order[tcl1] - allocno_class_order[tcl2]) != 0)
    1159                 :            :     return diff;
    1160                 :    1284300 :   return (int) cl1 - (int) cl2;
    1161                 :            : }
    1162                 :            : 
    1163                 :            : /* For correct work of function setup_reg_class_relation we need to
    1164                 :            :    reorder important classes according to the order of their allocno
    1165                 :            :    classes.  It places important classes containing the same
    1166                 :            :    allocatable hard register set adjacent to each other and allocno
    1167                 :            :    class with the allocatable hard register set right after the other
    1168                 :            :    important classes with the same set.
    1169                 :            : 
    1170                 :            :    In example from comments of function
    1171                 :            :    setup_allocno_and_important_classes, it places LEGACY_REGS and
    1172                 :            :    GENERAL_REGS close to each other and GENERAL_REGS is after
    1173                 :            :    LEGACY_REGS.  */
    1174                 :            : static void
    1175                 :     151861 : reorder_important_classes (void)
    1176                 :            : {
    1177                 :     151861 :   int i;
    1178                 :            : 
    1179                 :    4707690 :   for (i = 0; i < N_REG_CLASSES; i++)
    1180                 :    4555830 :     allocno_class_order[i] = -1;
    1181                 :    3941580 :   for (i = 0; i < ira_allocno_classes_num; i++)
    1182                 :    3789720 :     allocno_class_order[ira_allocno_classes[i]] = i;
    1183                 :     151861 :   qsort (ira_important_classes, ira_important_classes_num,
    1184                 :            :          sizeof (enum reg_class), comp_reg_classes_func);
    1185                 :    4253870 :   for (i = 0; i < ira_important_classes_num; i++)
    1186                 :    4102010 :     ira_important_class_nums[ira_important_classes[i]] = i;
    1187                 :     151861 : }
    1188                 :            : 
    1189                 :            : /* Set up IRA_REG_CLASS_SUBUNION, IRA_REG_CLASS_SUPERUNION,
    1190                 :            :    IRA_REG_CLASS_SUPER_CLASSES, IRA_REG_CLASSES_INTERSECT, and
    1191                 :            :    IRA_REG_CLASSES_INTERSECT_P.  For the meaning of the relations,
    1192                 :            :    please see corresponding comments in ira-int.h.  */
    1193                 :            : static void
    1194                 :     151861 : setup_reg_class_relations (void)
    1195                 :            : {
    1196                 :     151861 :   int i, cl1, cl2, cl3;
    1197                 :     151861 :   HARD_REG_SET intersection_set, union_set, temp_set2;
    1198                 :     151861 :   bool important_class_p[N_REG_CLASSES];
    1199                 :            : 
    1200                 :     151861 :   memset (important_class_p, 0, sizeof (important_class_p));
    1201                 :    4253870 :   for (i = 0; i < ira_important_classes_num; i++)
    1202                 :    4102010 :     important_class_p[ira_important_classes[i]] = true;
    1203                 :    4707690 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1204                 :            :     {
    1205                 :    4555830 :       ira_reg_class_super_classes[cl1][0] = LIM_REG_CLASSES;
    1206                 :  141231000 :       for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1207                 :            :         {
    1208                 :  136675000 :           ira_reg_classes_intersect_p[cl1][cl2] = false;
    1209                 :  136675000 :           ira_reg_class_intersect[cl1][cl2] = NO_REGS;
    1210                 :  136675000 :           ira_reg_class_subset[cl1][cl2] = NO_REGS;
    1211                 :  273350000 :           temp_hard_regset = reg_class_contents[cl1] & ~no_unit_alloc_regs;
    1212                 :  273350000 :           temp_set2 = reg_class_contents[cl2] & ~no_unit_alloc_regs;
    1213                 :  136675000 :           if (hard_reg_set_empty_p (temp_hard_regset)
    1214                 :  150289000 :               && hard_reg_set_empty_p (temp_set2))
    1215                 :            :             {
    1216                 :            :               /* The both classes have no allocatable hard registers
    1217                 :            :                  -- take all class hard registers into account and use
    1218                 :            :                  reg_class_subunion and reg_class_superunion.  */
    1219                 :     506993 :               for (i = 0;; i++)
    1220                 :            :                 {
    1221                 :    1904650 :                   cl3 = reg_class_subclasses[cl1][i];
    1222                 :    1904650 :                   if (cl3 == LIM_REG_CLASSES)
    1223                 :            :                     break;
    1224                 :     506993 :                   if (reg_class_subset_p (ira_reg_class_intersect[cl1][cl2],
    1225                 :            :                                           (enum reg_class) cl3))
    1226                 :     490535 :                     ira_reg_class_intersect[cl1][cl2] = (enum reg_class) cl3;
    1227                 :            :                 }
    1228                 :    1397660 :               ira_reg_class_subunion[cl1][cl2] = reg_class_subunion[cl1][cl2];
    1229                 :    1397660 :               ira_reg_class_superunion[cl1][cl2] = reg_class_superunion[cl1][cl2];
    1230                 :    1397660 :               continue;
    1231                 :            :             }
    1232                 :  405832000 :           ira_reg_classes_intersect_p[cl1][cl2]
    1233                 :  135277000 :             = hard_reg_set_intersect_p (temp_hard_regset, temp_set2);
    1234                 :  123060000 :           if (important_class_p[cl1] && important_class_p[cl2]
    1235                 :  246121000 :               && hard_reg_set_subset_p (temp_hard_regset, temp_set2))
    1236                 :            :             {
    1237                 :            :               /* CL1 and CL2 are important classes and CL1 allocatable
    1238                 :            :                  hard register set is inside of CL2 allocatable hard
    1239                 :            :                  registers -- make CL1 a superset of CL2.  */
    1240                 :   28005700 :               enum reg_class *p;
    1241                 :            : 
    1242                 :   28005700 :               p = &ira_reg_class_super_classes[cl1][0];
    1243                 :  129155000 :               while (*p != LIM_REG_CLASSES)
    1244                 :  101150000 :                 p++;
    1245                 :   28005700 :               *p++ = (enum reg_class) cl2;
    1246                 :   28005700 :               *p = LIM_REG_CLASSES;
    1247                 :            :             }
    1248                 :  135277000 :           ira_reg_class_subunion[cl1][cl2] = NO_REGS;
    1249                 :  135277000 :           ira_reg_class_superunion[cl1][cl2] = NO_REGS;
    1250                 :  135277000 :           intersection_set = (reg_class_contents[cl1]
    1251                 :  135277000 :                               & reg_class_contents[cl2]
    1252                 :  270554000 :                               & ~no_unit_alloc_regs);
    1253                 :  135277000 :           union_set = ((reg_class_contents[cl1] | reg_class_contents[cl2])
    1254                 :  270554000 :                        & ~no_unit_alloc_regs);
    1255                 : 4193590000 :           for (cl3 = 0; cl3 < N_REG_CLASSES; cl3++)
    1256                 :            :             {
    1257                 :12175000000 :               temp_hard_regset = reg_class_contents[cl3] & ~no_unit_alloc_regs;
    1258                 : 8116630000 :               if (hard_reg_set_subset_p (temp_hard_regset, intersection_set))
    1259                 :            :                 {
    1260                 :            :                   /* CL3 allocatable hard register set is inside of
    1261                 :            :                      intersection of allocatable hard register sets
    1262                 :            :                      of CL1 and CL2.  */
    1263                 :  634136000 :                   if (important_class_p[cl3])
    1264                 :            :                     {
    1265                 :  230305000 :                       temp_set2
    1266                 :  230305000 :                         = (reg_class_contents
    1267                 :  230305000 :                            [ira_reg_class_intersect[cl1][cl2]]);
    1268                 :  460610000 :                       temp_set2 &= ~no_unit_alloc_regs;
    1269                 :  230305000 :                       if (! hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1270                 :            :                           /* If the allocatable hard register sets are
    1271                 :            :                              the same, prefer GENERAL_REGS or the
    1272                 :            :                              smallest class for debugging
    1273                 :            :                              purposes.  */
    1274                 :  247579000 :                           || (temp_hard_regset == temp_set2
    1275                 :   11409400 :                               && (cl3 == GENERAL_REGS
    1276                 :    5882490 :                                   || ((ira_reg_class_intersect[cl1][cl2]
    1277                 :            :                                        != GENERAL_REGS)
    1278                 :    5837100 :                                       && hard_reg_set_subset_p
    1279                 :   17511300 :                                          (reg_class_contents[cl3],
    1280                 :            :                                           reg_class_contents
    1281                 :            :                                           [(int)
    1282                 :            :                                            ira_reg_class_intersect[cl1][cl2]])))))
    1283                 :  218558000 :                         ira_reg_class_intersect[cl1][cl2] = (enum reg_class) cl3;
    1284                 :            :                     }
    1285                 :            :                   temp_set2
    1286                 :  634136000 :                     = (reg_class_contents[ira_reg_class_subset[cl1][cl2]]
    1287                 : 1902410000 :                        & ~no_unit_alloc_regs);
    1288                 :  634136000 :                   if (! hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1289                 :            :                       /* Ignore unavailable hard registers and prefer
    1290                 :            :                          smallest class for debugging purposes.  */
    1291                 : 1055240000 :                       || (temp_hard_regset == temp_set2
    1292                 :  307873000 :                           && hard_reg_set_subset_p
    1293                 :  923618000 :                              (reg_class_contents[cl3],
    1294                 :            :                               reg_class_contents
    1295                 :            :                               [(int) ira_reg_class_subset[cl1][cl2]])))
    1296                 :  348308000 :                     ira_reg_class_subset[cl1][cl2] = (enum reg_class) cl3;
    1297                 :            :                 }
    1298                 : 4058320000 :               if (important_class_p[cl3]
    1299                 : 7712800000 :                   && hard_reg_set_subset_p (temp_hard_regset, union_set))
    1300                 :            :                 {
    1301                 :            :                   /* CL3 allocatable hard register set is inside of
    1302                 :            :                      union of allocatable hard register sets of CL1
    1303                 :            :                      and CL2.  */
    1304                 :            :                   temp_set2
    1305                 : 1467080000 :                     = (reg_class_contents[ira_reg_class_subunion[cl1][cl2]]
    1306                 : 4401230000 :                        & ~no_unit_alloc_regs);
    1307                 : 1467080000 :                   if (ira_reg_class_subunion[cl1][cl2] == NO_REGS
    1308                 : 2798880000 :                       || (hard_reg_set_subset_p (temp_set2, temp_hard_regset)
    1309                 :            :                           
    1310                 :  360604000 :                           && (temp_set2 != temp_hard_regset
    1311                 :   57734000 :                               || cl3 == GENERAL_REGS
    1312                 :            :                               /* If the allocatable hard register sets are the
    1313                 :            :                                  same, prefer GENERAL_REGS or the smallest
    1314                 :            :                                  class for debugging purposes.  */
    1315                 :    6795960 :                               || (ira_reg_class_subunion[cl1][cl2] != GENERAL_REGS
    1316                 :    6430180 :                                   && hard_reg_set_subset_p
    1317                 :   19290600 :                                      (reg_class_contents[cl3],
    1318                 :            :                                       reg_class_contents
    1319                 :            :                                       [(int) ira_reg_class_subunion[cl1][cl2]])))))
    1320                 :  489085000 :                     ira_reg_class_subunion[cl1][cl2] = (enum reg_class) cl3;
    1321                 :            :                 }
    1322                 : 8116630000 :               if (hard_reg_set_subset_p (union_set, temp_hard_regset))
    1323                 :            :                 {
    1324                 :            :                   /* CL3 allocatable hard register set contains union
    1325                 :            :                      of allocatable hard register sets of CL1 and
    1326                 :            :                      CL2.  */
    1327                 :            :                   temp_set2
    1328                 :  593847000 :                     = (reg_class_contents[ira_reg_class_superunion[cl1][cl2]]
    1329                 : 1781540000 :                        & ~no_unit_alloc_regs);
    1330                 :  593847000 :                   if (ira_reg_class_superunion[cl1][cl2] == NO_REGS
    1331                 : 1052420000 :                       || (hard_reg_set_subset_p (temp_hard_regset, temp_set2)
    1332                 :            : 
    1333                 :   23293700 :                           && (temp_set2 != temp_hard_regset
    1334                 :   17756800 :                               || cl3 == GENERAL_REGS
    1335                 :            :                               /* If the allocatable hard register sets are the
    1336                 :            :                                  same, prefer GENERAL_REGS or the smallest
    1337                 :            :                                  class for debugging purposes.  */
    1338                 :    5131520 :                               || (ira_reg_class_superunion[cl1][cl2] != GENERAL_REGS
    1339                 :    4760420 :                                   && hard_reg_set_subset_p
    1340                 :   14281300 :                                      (reg_class_contents[cl3],
    1341                 :            :                                       reg_class_contents
    1342                 :            :                                       [(int) ira_reg_class_superunion[cl1][cl2]])))))
    1343                 :  153439000 :                     ira_reg_class_superunion[cl1][cl2] = (enum reg_class) cl3;
    1344                 :            :                 }
    1345                 :            :             }
    1346                 :            :         }
    1347                 :            :     }
    1348                 :     151861 : }
    1349                 :            : 
    1350                 :            : /* Output all uniform and important classes into file F.  */
    1351                 :            : static void
    1352                 :          0 : print_uniform_and_important_classes (FILE *f)
    1353                 :            : {
    1354                 :          0 :   int i, cl;
    1355                 :            : 
    1356                 :          0 :   fprintf (f, "Uniform classes:\n");
    1357                 :          0 :   for (cl = 0; cl < N_REG_CLASSES; cl++)
    1358                 :          0 :     if (ira_uniform_class_p[cl])
    1359                 :          0 :       fprintf (f, " %s", reg_class_names[cl]);
    1360                 :          0 :   fprintf (f, "\nImportant classes:\n");
    1361                 :          0 :   for (i = 0; i < ira_important_classes_num; i++)
    1362                 :          0 :     fprintf (f, " %s", reg_class_names[ira_important_classes[i]]);
    1363                 :          0 :   fprintf (f, "\n");
    1364                 :          0 : }
    1365                 :            : 
    1366                 :            : /* Output all possible allocno or pressure classes and their
    1367                 :            :    translation map into file F.  */
    1368                 :            : static void
    1369                 :          0 : print_translated_classes (FILE *f, bool pressure_p)
    1370                 :            : {
    1371                 :          0 :   int classes_num = (pressure_p
    1372                 :          0 :                      ? ira_pressure_classes_num : ira_allocno_classes_num);
    1373                 :          0 :   enum reg_class *classes = (pressure_p
    1374                 :          0 :                              ? ira_pressure_classes : ira_allocno_classes);
    1375                 :          0 :   enum reg_class *class_translate = (pressure_p
    1376                 :          0 :                                      ? ira_pressure_class_translate
    1377                 :          0 :                                      : ira_allocno_class_translate);
    1378                 :          0 :   int i;
    1379                 :            : 
    1380                 :          0 :   fprintf (f, "%s classes:\n", pressure_p ? "Pressure" : "Allocno");
    1381                 :          0 :   for (i = 0; i < classes_num; i++)
    1382                 :          0 :     fprintf (f, " %s", reg_class_names[classes[i]]);
    1383                 :          0 :   fprintf (f, "\nClass translation:\n");
    1384                 :          0 :   for (i = 0; i < N_REG_CLASSES; i++)
    1385                 :          0 :     fprintf (f, " %s -> %s\n", reg_class_names[i],
    1386                 :          0 :              reg_class_names[class_translate[i]]);
    1387                 :          0 : }
    1388                 :            : 
    1389                 :            : /* Output all possible allocno and translation classes and the
    1390                 :            :    translation maps into stderr.  */
    1391                 :            : void
    1392                 :          0 : ira_debug_allocno_classes (void)
    1393                 :            : {
    1394                 :          0 :   print_uniform_and_important_classes (stderr);
    1395                 :          0 :   print_translated_classes (stderr, false);
    1396                 :          0 :   print_translated_classes (stderr, true);
    1397                 :          0 : }
    1398                 :            : 
    1399                 :            : /* Set up different arrays concerning class subsets, allocno and
    1400                 :            :    important classes.  */
    1401                 :            : static void
    1402                 :     151861 : find_reg_classes (void)
    1403                 :            : {
    1404                 :     151861 :   setup_allocno_and_important_classes ();
    1405                 :     151861 :   setup_class_translate ();
    1406                 :     151861 :   reorder_important_classes ();
    1407                 :     151861 :   setup_reg_class_relations ();
    1408                 :     151861 : }
    1409                 :            : 
    1410                 :            : 
    1411                 :            : 
    1412                 :            : /* Set up the array above.  */
    1413                 :            : static void
    1414                 :     151861 : setup_hard_regno_aclass (void)
    1415                 :            : {
    1416                 :     151861 :   int i;
    1417                 :            : 
    1418                 :   11693300 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1419                 :            :     {
    1420                 :            : #if 1
    1421                 :   23082900 :       ira_hard_regno_allocno_class[i]
    1422                 :   18619900 :         = (TEST_HARD_REG_BIT (no_unit_alloc_regs, i)
    1423                 :   11541400 :            ? NO_REGS
    1424                 :    7078450 :            : ira_allocno_class_translate[REGNO_REG_CLASS (i)]);
    1425                 :            : #else
    1426                 :            :       int j;
    1427                 :            :       enum reg_class cl;
    1428                 :            :       ira_hard_regno_allocno_class[i] = NO_REGS;
    1429                 :            :       for (j = 0; j < ira_allocno_classes_num; j++)
    1430                 :            :         {
    1431                 :            :           cl = ira_allocno_classes[j];
    1432                 :            :           if (ira_class_hard_reg_index[cl][i] >= 0)
    1433                 :            :             {
    1434                 :            :               ira_hard_regno_allocno_class[i] = cl;
    1435                 :            :               break;
    1436                 :            :             }
    1437                 :            :         }
    1438                 :            : #endif
    1439                 :            :     }
    1440                 :          0 : }
    1441                 :            : 
    1442                 :            : 
    1443                 :            : 
    1444                 :            : /* Form IRA_REG_CLASS_MAX_NREGS and IRA_REG_CLASS_MIN_NREGS maps.  */
    1445                 :            : static void
    1446                 :     151861 : setup_reg_class_nregs (void)
    1447                 :            : {
    1448                 :     151861 :   int i, cl, cl2, m;
    1449                 :            : 
    1450                 :   17008400 :   for (m = 0; m < MAX_MACHINE_MODE; m++)
    1451                 :            :     {
    1452                 :  522554000 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
    1453                 : 1011390000 :         ira_reg_class_max_nregs[cl][m]
    1454                 : 1011390000 :           = ira_reg_class_min_nregs[cl][m]
    1455                 :  505697000 :           = targetm.class_max_nregs ((reg_class_t) cl, (machine_mode) m);
    1456                 :  522554000 :       for (cl = 0; cl < N_REG_CLASSES; cl++)
    1457                 : 2653310000 :         for (i = 0;
    1458                 : 3159000000 :              (cl2 = alloc_reg_class_subclasses[cl][i]) != LIM_REG_CLASSES;
    1459                 :            :              i++)
    1460                 : 2653310000 :           if (ira_reg_class_min_nregs[cl2][m]
    1461                 : 2653310000 :               < ira_reg_class_min_nregs[cl][m])
    1462                 :   33595000 :             ira_reg_class_min_nregs[cl][m] = ira_reg_class_min_nregs[cl2][m];
    1463                 :            :     }
    1464                 :     151861 : }
    1465                 :            : 
    1466                 :            : 
    1467                 :            : 
    1468                 :            : /* Set up IRA_PROHIBITED_CLASS_MODE_REGS and IRA_CLASS_SINGLETON.
    1469                 :            :    This function is called once IRA_CLASS_HARD_REGS has been initialized.  */
    1470                 :            : static void
    1471                 :     151861 : setup_prohibited_class_mode_regs (void)
    1472                 :            : {
    1473                 :     151861 :   int j, k, hard_regno, cl, last_hard_regno, count;
    1474                 :            : 
    1475                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
    1476                 :            :     {
    1477                 :    9111660 :       temp_hard_regset = reg_class_contents[cl] & ~no_unit_alloc_regs;
    1478                 :  510253000 :       for (j = 0; j < NUM_MACHINE_MODES; j++)
    1479                 :            :         {
    1480                 :  505697000 :           count = 0;
    1481                 :  505697000 :           last_hard_regno = -1;
    1482                 :  505697000 :           CLEAR_HARD_REG_SET (ira_prohibited_class_mode_regs[cl][j]);
    1483                 : 5458950000 :           for (k = ira_class_hard_regs_num[cl] - 1; k >= 0; k--)
    1484                 :            :             {
    1485                 : 4953250000 :               hard_regno = ira_class_hard_regs[cl][k];
    1486                 : 4953250000 :               if (!targetm.hard_regno_mode_ok (hard_regno, (machine_mode) j))
    1487                 : 4953250000 :                 SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1488                 :            :                                   hard_regno);
    1489                 :  867307000 :               else if (in_hard_reg_set_p (temp_hard_regset,
    1490                 :            :                                           (machine_mode) j, hard_regno))
    1491                 :            :                 {
    1492                 :  815616000 :                   last_hard_regno = hard_regno;
    1493                 :  815616000 :                   count++;
    1494                 :            :                 }
    1495                 :            :             }
    1496                 :  526724000 :           ira_class_singleton[cl][j] = (count == 1 ? last_hard_regno : -1);
    1497                 :            :         }
    1498                 :            :     }
    1499                 :     151861 : }
    1500                 :            : 
    1501                 :            : /* Clarify IRA_PROHIBITED_CLASS_MODE_REGS by excluding hard registers
    1502                 :            :    spanning from one register pressure class to another one.  It is
    1503                 :            :    called after defining the pressure classes.  */
    1504                 :            : static void
    1505                 :     151861 : clarify_prohibited_class_mode_regs (void)
    1506                 :            : {
    1507                 :     151861 :   int j, k, hard_regno, cl, pclass, nregs;
    1508                 :            : 
    1509                 :    4707690 :   for (cl = (int) N_REG_CLASSES - 1; cl >= 0; cl--)
    1510                 :  510253000 :     for (j = 0; j < NUM_MACHINE_MODES; j++)
    1511                 :            :       {
    1512                 :  505697000 :         CLEAR_HARD_REG_SET (ira_useful_class_mode_regs[cl][j]);
    1513                 : 5458950000 :         for (k = ira_class_hard_regs_num[cl] - 1; k >= 0; k--)
    1514                 :            :           {
    1515                 : 4953250000 :             hard_regno = ira_class_hard_regs[cl][k];
    1516                 : 4953250000 :             if (TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j], hard_regno))
    1517                 : 4085940000 :               continue;
    1518                 :  867307000 :             nregs = hard_regno_nregs (hard_regno, (machine_mode) j);
    1519                 :  867307000 :             if (hard_regno + nregs > FIRST_PSEUDO_REGISTER)
    1520                 :            :               {
    1521                 :          0 :                 SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1522                 :            :                                   hard_regno);
    1523                 :          0 :                  continue;
    1524                 :            :               }
    1525                 :  867307000 :             pclass = ira_pressure_class_translate[REGNO_REG_CLASS (hard_regno)];
    1526                 : 1967960000 :             for (nregs-- ;nregs >= 0; nregs--)
    1527                 : 1126540000 :               if (((enum reg_class) pclass
    1528                 : 1126540000 :                    != ira_pressure_class_translate[REGNO_REG_CLASS
    1529                 : 1126540000 :                                                    (hard_regno + nregs)]))
    1530                 :            :                 {
    1531                 :   25884000 :                   SET_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1532                 :            :                                     hard_regno);
    1533                 :            :                   break;
    1534                 :            :                 }
    1535                 :  867307000 :             if (!TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[cl][j],
    1536                 :            :                                     hard_regno))
    1537                 : 5794670000 :               add_to_hard_reg_set (&ira_useful_class_mode_regs[cl][j],
    1538                 :            :                                    (machine_mode) j, hard_regno);
    1539                 :            :           }
    1540                 :            :       }
    1541                 :     151861 : }
    1542                 :            : 
    1543                 :            : /* Allocate and initialize IRA_REGISTER_MOVE_COST, IRA_MAY_MOVE_IN_COST
    1544                 :            :    and IRA_MAY_MOVE_OUT_COST for MODE.  */
    1545                 :            : void
    1546                 :    5084060 : ira_init_register_move_cost (machine_mode mode)
    1547                 :            : {
    1548                 :    5084060 :   static unsigned short last_move_cost[N_REG_CLASSES][N_REG_CLASSES];
    1549                 :    5084060 :   bool all_match = true;
    1550                 :    5084060 :   unsigned int i, cl1, cl2;
    1551                 :    5084060 :   HARD_REG_SET ok_regs;
    1552                 :            : 
    1553                 :    5084060 :   ira_assert (ira_register_move_cost[mode] == NULL
    1554                 :            :               && ira_may_move_in_cost[mode] == NULL
    1555                 :            :               && ira_may_move_out_cost[mode] == NULL);
    1556                 :   15252200 :   CLEAR_HARD_REG_SET (ok_regs);
    1557                 :  391473000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1558                 :  386389000 :     if (targetm.hard_regno_mode_ok (i, mode))
    1559                 :  386389000 :       SET_HARD_REG_BIT (ok_regs, i);
    1560                 :            : 
    1561                 :            :   /* Note that we might be asked about the move costs of modes that
    1562                 :            :      cannot be stored in any hard register, for example if an inline
    1563                 :            :      asm tries to create a register operand with an impossible mode.
    1564                 :            :      We therefore can't assert have_regs_of_mode[mode] here.  */
    1565                 :  157606000 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1566                 : 4728180000 :     for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1567                 :            :       {
    1568                 : 4575660000 :         int cost;
    1569                 : 4575660000 :         if (!hard_reg_set_intersect_p (ok_regs, reg_class_contents[cl1])
    1570                 :10180300000 :             || !hard_reg_set_intersect_p (ok_regs, reg_class_contents[cl2]))
    1571                 :            :           {
    1572                 : 2665190000 :             if ((ira_reg_class_max_nregs[cl1][mode]
    1573                 : 2665190000 :                  > ira_class_hard_regs_num[cl1])
    1574                 : 1819060000 :                 || (ira_reg_class_max_nregs[cl2][mode]
    1575                 : 1819060000 :                     > ira_class_hard_regs_num[cl2]))
    1576                 :            :               cost = 65535;
    1577                 :            :             else
    1578                 : 1219030000 :               cost = (ira_memory_move_cost[mode][cl1][0]
    1579                 : 1219030000 :                       + ira_memory_move_cost[mode][cl2][1]) * 2;
    1580                 :            :           }
    1581                 :            :         else
    1582                 :            :           {
    1583                 : 1910470000 :             cost = register_move_cost (mode, (enum reg_class) cl1,
    1584                 :            :                                        (enum reg_class) cl2);
    1585                 : 1910470000 :             ira_assert (cost < 65535);
    1586                 :            :           }
    1587                 : 4575660000 :         all_match &= (last_move_cost[cl1][cl2] == cost);
    1588                 : 4575660000 :         last_move_cost[cl1][cl2] = cost;
    1589                 :            :       }
    1590                 :    5084060 :   if (all_match && last_mode_for_init_move_cost != -1)
    1591                 :            :     {
    1592                 :    1850640 :       ira_register_move_cost[mode]
    1593                 :    1850640 :         = ira_register_move_cost[last_mode_for_init_move_cost];
    1594                 :    1850640 :       ira_may_move_in_cost[mode]
    1595                 :    1850640 :         = ira_may_move_in_cost[last_mode_for_init_move_cost];
    1596                 :    1850640 :       ira_may_move_out_cost[mode]
    1597                 :    1850640 :         = ira_may_move_out_cost[last_mode_for_init_move_cost];
    1598                 :    1850640 :       return;
    1599                 :            :     }
    1600                 :    3233420 :   last_mode_for_init_move_cost = mode;
    1601                 :    3233420 :   ira_register_move_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1602                 :    3233420 :   ira_may_move_in_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1603                 :    3233420 :   ira_may_move_out_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
    1604                 :  100236000 :   for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
    1605                 : 3007080000 :     for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
    1606                 :            :       {
    1607                 : 2910080000 :         int cost;
    1608                 : 2910080000 :         enum reg_class *p1, *p2;
    1609                 :            :         
    1610                 : 2910080000 :         if (last_move_cost[cl1][cl2] == 65535)
    1611                 :            :           {
    1612                 :  835446000 :             ira_register_move_cost[mode][cl1][cl2] = 65535;
    1613                 :  835446000 :             ira_may_move_in_cost[mode][cl1][cl2] = 65535;
    1614                 :  835446000 :             ira_may_move_out_cost[mode][cl1][cl2] = 65535;
    1615                 :            :           }
    1616                 :            :         else
    1617                 :            :           {
    1618                 : 2074630000 :             cost = last_move_cost[cl1][cl2];
    1619                 :            :             
    1620                 :14765800000 :             for (p2 = &reg_class_subclasses[cl2][0];
    1621                 :14765800000 :                  *p2 != LIM_REG_CLASSES; p2++)
    1622                 :12691200000 :               if (ira_class_hard_regs_num[*p2] > 0
    1623                 :12517500000 :                   && (ira_reg_class_max_nregs[*p2][mode]
    1624                 :            :                       <= ira_class_hard_regs_num[*p2]))
    1625                 : 9623070000 :                 cost = MAX (cost, ira_register_move_cost[mode][cl1][*p2]);
    1626                 :            :             
    1627                 :14765800000 :             for (p1 = &reg_class_subclasses[cl1][0];
    1628                 :14765800000 :                  *p1 != LIM_REG_CLASSES; p1++)
    1629                 :12691200000 :               if (ira_class_hard_regs_num[*p1] > 0
    1630                 :12517500000 :                   && (ira_reg_class_max_nregs[*p1][mode]
    1631                 :            :                       <= ira_class_hard_regs_num[*p1]))
    1632                 : 9623070000 :                 cost = MAX (cost, ira_register_move_cost[mode][*p1][cl2]);
    1633                 :            :             
    1634                 : 2074630000 :             ira_assert (cost <= 65535);
    1635                 : 2074630000 :             ira_register_move_cost[mode][cl1][cl2] = cost;
    1636                 :            :             
    1637                 : 2074630000 :             if (ira_class_subset_p[cl1][cl2])
    1638                 :  569520000 :               ira_may_move_in_cost[mode][cl1][cl2] = 0;
    1639                 :            :             else
    1640                 : 1505110000 :               ira_may_move_in_cost[mode][cl1][cl2] = cost;
    1641                 :            :             
    1642                 : 2074630000 :             if (ira_class_subset_p[cl2][cl1])
    1643                 :  569520000 :               ira_may_move_out_cost[mode][cl1][cl2] = 0;
    1644                 :            :             else
    1645                 : 1505110000 :               ira_may_move_out_cost[mode][cl1][cl2] = cost;
    1646                 :            :           }
    1647                 :            :       }
    1648                 :            : }
    1649                 :            : 
    1650                 :            : 
    1651                 :            : 
    1652                 :            : /* This is called once during compiler work.  It sets up
    1653                 :            :    different arrays whose values don't depend on the compiled
    1654                 :            :    function.  */
    1655                 :            : void
    1656                 :     149606 : ira_init_once (void)
    1657                 :            : {
    1658                 :     149606 :   ira_init_costs_once ();
    1659                 :     149606 :   lra_init_once ();
    1660                 :            : 
    1661                 :     149606 :   ira_use_lra_p = targetm.lra_p ();
    1662                 :     149606 : }
    1663                 :            : 
    1664                 :            : /* Free ira_max_register_move_cost, ira_may_move_in_cost and
    1665                 :            :    ira_may_move_out_cost for each mode.  */
    1666                 :            : void
    1667                 :     352167 : target_ira_int::free_register_move_costs (void)
    1668                 :            : {
    1669                 :     352167 :   int mode, i;
    1670                 :            : 
    1671                 :            :   /* Reset move_cost and friends, making sure we only free shared
    1672                 :            :      table entries once.  */
    1673                 :   39442700 :   for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
    1674                 :   39090500 :     if (x_ira_register_move_cost[mode])
    1675                 :            :       {
    1676                 :  264781000 :         for (i = 0;
    1677                 :  269494000 :              i < mode && (x_ira_register_move_cost[i]
    1678                 :            :                           != x_ira_register_move_cost[mode]);
    1679                 :            :              i++)
    1680                 :            :           ;
    1681                 :    4713190 :         if (i == mode)
    1682                 :            :           {
    1683                 :    3000240 :             free (x_ira_register_move_cost[mode]);
    1684                 :    3000240 :             free (x_ira_may_move_in_cost[mode]);
    1685                 :    3000240 :             free (x_ira_may_move_out_cost[mode]);
    1686                 :            :           }
    1687                 :            :       }
    1688                 :     352167 :   memset (x_ira_register_move_cost, 0, sizeof x_ira_register_move_cost);
    1689                 :     352167 :   memset (x_ira_may_move_in_cost, 0, sizeof x_ira_may_move_in_cost);
    1690                 :     352167 :   memset (x_ira_may_move_out_cost, 0, sizeof x_ira_may_move_out_cost);
    1691                 :     352167 :   last_mode_for_init_move_cost = -1;
    1692                 :     352167 : }
    1693                 :            : 
    1694                 :     400612 : target_ira_int::~target_ira_int ()
    1695                 :            : {
    1696                 :     200306 :   free_ira_costs ();
    1697                 :     200306 :   free_register_move_costs ();
    1698                 :     200306 : }
    1699                 :            : 
    1700                 :            : /* This is called every time when register related information is
    1701                 :            :    changed.  */
    1702                 :            : void
    1703                 :     151861 : ira_init (void)
    1704                 :            : {
    1705                 :     151861 :   this_target_ira_int->free_register_move_costs ();
    1706                 :     151861 :   setup_reg_mode_hard_regset ();
    1707                 :     151861 :   setup_alloc_regs (flag_omit_frame_pointer != 0);
    1708                 :     151861 :   setup_class_subset_and_memory_move_costs ();
    1709                 :     151861 :   setup_reg_class_nregs ();
    1710                 :     151861 :   setup_prohibited_class_mode_regs ();
    1711                 :     151861 :   find_reg_classes ();
    1712                 :     151861 :   clarify_prohibited_class_mode_regs ();
    1713                 :     151861 :   setup_hard_regno_aclass ();
    1714                 :     151861 :   ira_init_costs ();
    1715                 :     151861 : }
    1716                 :            : 
    1717                 :            : 
    1718                 :            : #define ira_prohibited_mode_move_regs_initialized_p \
    1719                 :            :   (this_target_ira_int->x_ira_prohibited_mode_move_regs_initialized_p)
    1720                 :            : 
    1721                 :            : /* Set up IRA_PROHIBITED_MODE_MOVE_REGS.  */
    1722                 :            : static void
    1723                 :     944096 : setup_prohibited_mode_move_regs (void)
    1724                 :            : {
    1725                 :     944096 :   int i, j;
    1726                 :     944096 :   rtx test_reg1, test_reg2, move_pat;
    1727                 :     944096 :   rtx_insn *move_insn;
    1728                 :            : 
    1729                 :     944096 :   if (ira_prohibited_mode_move_regs_initialized_p)
    1730                 :            :     return;
    1731                 :     150780 :   ira_prohibited_mode_move_regs_initialized_p = true;
    1732                 :     150780 :   test_reg1 = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
    1733                 :     150780 :   test_reg2 = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 2);
    1734                 :     150780 :   move_pat = gen_rtx_SET (test_reg1, test_reg2);
    1735                 :     150780 :   move_insn = gen_rtx_INSN (VOIDmode, 0, 0, 0, move_pat, 0, -1, 0);
    1736                 :   16887400 :   for (i = 0; i < NUM_MACHINE_MODES; i++)
    1737                 :            :     {
    1738                 :   16736600 :       SET_HARD_REG_SET (ira_prohibited_mode_move_regs[i]);
    1739                 : 1288720000 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
    1740                 :            :         {
    1741                 : 1271980000 :           if (!targetm.hard_regno_mode_ok (j, (machine_mode) i))
    1742                 : 1129820000 :             continue;
    1743                 :  142159000 :           set_mode_and_regno (test_reg1, (machine_mode) i, j);
    1744                 :  142159000 :           set_mode_and_regno (test_reg2, (machine_mode) i, j);
    1745                 :  142159000 :           INSN_CODE (move_insn) = -1;
    1746                 :  142159000 :           recog_memoized (move_insn);
    1747                 :  142159000 :           if (INSN_CODE (move_insn) < 0)
    1748                 :   46655000 :             continue;
    1749                 :   95504500 :           extract_insn (move_insn);
    1750                 :            :           /* We don't know whether the move will be in code that is optimized
    1751                 :            :              for size or speed, so consider all enabled alternatives.  */
    1752                 :   95504500 :           if (! constrain_operands (1, get_enabled_alternatives (move_insn)))
    1753                 :     916077 :             continue;
    1754                 : 1271980000 :           CLEAR_HARD_REG_BIT (ira_prohibited_mode_move_regs[i], j);
    1755                 :            :         }
    1756                 :            :     }
    1757                 :            : }
    1758                 :            : 
    1759                 :            : 
    1760                 :            : 
    1761                 :            : /* Extract INSN and return the set of alternatives that we should consider.
    1762                 :            :    This excludes any alternatives whose constraints are obviously impossible
    1763                 :            :    to meet (e.g. because the constraint requires a constant and the operand
    1764                 :            :    is nonconstant).  It also excludes alternatives that are bound to need
    1765                 :            :    a spill or reload, as long as we have other alternatives that match
    1766                 :            :    exactly.  */
    1767                 :            : alternative_mask
    1768                 :   64593400 : ira_setup_alts (rtx_insn *insn)
    1769                 :            : {
    1770                 :   64593400 :   int nop, nalt;
    1771                 :   64593400 :   bool curr_swapped;
    1772                 :   64593400 :   const char *p;
    1773                 :   64593400 :   int commutative = -1;
    1774                 :            : 
    1775                 :   64593400 :   extract_insn (insn);
    1776                 :   64593400 :   preprocess_constraints (insn);
    1777                 :   64593400 :   alternative_mask preferred = get_preferred_alternatives (insn);
    1778                 :   64593400 :   alternative_mask alts = 0;
    1779                 :   64593400 :   alternative_mask exact_alts = 0;
    1780                 :            :   /* Check that the hard reg set is enough for holding all
    1781                 :            :      alternatives.  It is hard to imagine the situation when the
    1782                 :            :      assertion is wrong.  */
    1783                 :   64593400 :   ira_assert (recog_data.n_alternatives
    1784                 :            :               <= (int) MAX (sizeof (HARD_REG_ELT_TYPE) * CHAR_BIT,
    1785                 :            :                             FIRST_PSEUDO_REGISTER));
    1786                 :  189508000 :   for (nop = 0; nop < recog_data.n_operands; nop++)
    1787                 :  132015000 :     if (recog_data.constraints[nop][0] == '%')
    1788                 :            :       {
    1789                 :            :         commutative = nop;
    1790                 :            :         break;
    1791                 :            :       }
    1792                 :   64593400 :   for (curr_swapped = false;; curr_swapped = true)
    1793                 :            :     {
    1794                 :  799768000 :       for (nalt = 0; nalt < recog_data.n_alternatives; nalt++)
    1795                 :            :         {
    1796                 :  728074000 :           if (!TEST_BIT (preferred, nalt) || TEST_BIT (exact_alts, nalt))
    1797                 :  110220000 :             continue;
    1798                 :            : 
    1799                 :  617853000 :           const operand_alternative *op_alt
    1800                 :  617853000 :             = &recog_op_alt[nalt * recog_data.n_operands];
    1801                 :  617853000 :           int this_reject = 0;
    1802                 : 1606340000 :           for (nop = 0; nop < recog_data.n_operands; nop++)
    1803                 :            :             {
    1804                 : 1196450000 :               int c, len;
    1805                 :            : 
    1806                 : 1196450000 :               this_reject += op_alt[nop].reject;
    1807                 :            : 
    1808                 : 1196450000 :               rtx op = recog_data.operand[nop];
    1809                 : 1196450000 :               p = op_alt[nop].constraint;
    1810                 : 1196450000 :               if (*p == 0 || *p == ',')
    1811                 :   14700300 :                 continue;
    1812                 :            : 
    1813                 :            :               bool win_p = false;
    1814                 : 2572190000 :               do
    1815                 : 5122720000 :                 switch (c = *p, len = CONSTRAINT_LEN (c, p), c)
    1816                 :            :                   {
    1817                 :  536000000 :                   case '#':
    1818                 :  536000000 :                   case ',':
    1819                 :  536000000 :                     c = '\0';
    1820                 :            :                     /* FALLTHRU */
    1821                 :            :                   case '\0':
    1822                 :            :                     len = 0;
    1823                 :            :                     break;
    1824                 :            :                   
    1825                 :            :                   case '%':
    1826                 :            :                     /* The commutative modifier is handled above.  */
    1827                 :            :                     break;
    1828                 :            : 
    1829                 :   33112300 :                   case '0':  case '1':  case '2':  case '3':  case '4':
    1830                 :   33112300 :                   case '5':  case '6':  case '7':  case '8':  case '9':
    1831                 :   33112300 :                     {
    1832                 :   33112300 :                       rtx other = recog_data.operand[c - '0'];
    1833                 :   33112300 :                       if (MEM_P (other)
    1834                 :   65375200 :                           ? rtx_equal_p (other, op)
    1835                 :   32262900 :                           : REG_P (op) || SUBREG_P (op))
    1836                 :   23464500 :                         goto op_success;
    1837                 :            :                       win_p = true;
    1838                 :            :                     }
    1839                 :            :                     break;
    1840                 :            :                     
    1841                 :    8000390 :                   case 'g':
    1842                 :    8000390 :                     goto op_success;
    1843                 : 1956190000 :                     break;
    1844                 :            :                     
    1845                 : 1956190000 :                   default:
    1846                 : 1956190000 :                     {
    1847                 : 1956190000 :                       enum constraint_num cn = lookup_constraint (p);
    1848                 : 1956190000 :                       switch (get_constraint_type (cn))
    1849                 :            :                         {
    1850                 : 1638950000 :                         case CT_REGISTER:
    1851                 : 2529310000 :                           if (reg_class_for_constraint (cn) != NO_REGS)
    1852                 :            :                             {
    1853                 :  755404000 :                               if (REG_P (op) || SUBREG_P (op))
    1854                 :  486422000 :                                 goto op_success;
    1855                 :            :                               win_p = true;
    1856                 :            :                             }
    1857                 :            :                           break;
    1858                 :            : 
    1859                 :    2307500 :                         case CT_CONST_INT:
    1860                 :    2307500 :                           if (CONST_INT_P (op)
    1861                 :    3744220 :                               && (insn_const_int_ok_for_constraint
    1862                 :    1436720 :                                   (INTVAL (op), cn)))
    1863                 :     963495 :                             goto op_success;
    1864                 :            :                           break;
    1865                 :            : 
    1866                 :     518820 :                         case CT_ADDRESS:
    1867                 :     518820 :                           goto op_success;
    1868                 :            : 
    1869                 :  175843000 :                         case CT_MEMORY:
    1870                 :  175843000 :                         case CT_SPECIAL_MEMORY:
    1871                 :  175843000 :                           if (MEM_P (op))
    1872                 :   51221300 :                             goto op_success;
    1873                 :            :                           win_p = true;
    1874                 :            :                           break;
    1875                 :            : 
    1876                 :  138571000 :                         case CT_FIXED_FORM:
    1877                 :  138571000 :                           if (constraint_satisfied_p (op, cn))
    1878                 :   43648500 :                             goto op_success;
    1879                 :            :                           break;
    1880                 :            :                         }
    1881                 :            :                       break;
    1882                 :            :                     }
    1883                 :            :                   }
    1884                 : 1957950000 :               while (p += len, c);
    1885                 :  567509000 :               if (!win_p)
    1886                 :            :                 break;
    1887                 :            :               /* We can make the alternative match by spilling a register
    1888                 :            :                  to memory or loading something into a register.  Count a
    1889                 :            :                  cost of one reload (the equivalent of the '?' constraint).  */
    1890                 :  359551000 :               this_reject += 6;
    1891                 :  988490000 :             op_success:
    1892                 :  988490000 :               ;
    1893                 :            :             }
    1894                 :            : 
    1895                 :  617853000 :           if (nop >= recog_data.n_operands)
    1896                 :            :             {
    1897                 :  409896000 :               alts |= ALTERNATIVE_BIT (nalt);
    1898                 :  409896000 :               if (this_reject == 0)
    1899                 :   98506600 :                 exact_alts |= ALTERNATIVE_BIT (nalt);
    1900                 :            :             }
    1901                 :            :         }
    1902                 :   71693900 :       if (commutative < 0)
    1903                 :            :         break;
    1904                 :            :       /* Swap forth and back to avoid changing recog_data.  */
    1905                 :   14200900 :       std::swap (recog_data.operand[commutative],
    1906                 :   14200900 :                  recog_data.operand[commutative + 1]);
    1907                 :   14200900 :       if (curr_swapped)
    1908                 :            :         break;
    1909                 :            :     }
    1910                 :   64593400 :   return exact_alts ? exact_alts : alts;
    1911                 :            : }
    1912                 :            : 
    1913                 :            : /* Return the number of the output non-early clobber operand which
    1914                 :            :    should be the same in any case as operand with number OP_NUM (or
    1915                 :            :    negative value if there is no such operand).  ALTS is the mask
    1916                 :            :    of alternatives that we should consider.  */
    1917                 :            : int
    1918                 :   12027500 : ira_get_dup_out_num (int op_num, alternative_mask alts)
    1919                 :            : {
    1920                 :   12027500 :   int curr_alt, c, original, dup;
    1921                 :   12027500 :   bool ignore_p, use_commut_op_p;
    1922                 :   12027500 :   const char *str;
    1923                 :            : 
    1924                 :   12027500 :   if (op_num < 0 || recog_data.n_alternatives == 0)
    1925                 :            :     return -1;
    1926                 :            :   /* We should find duplications only for input operands.  */
    1927                 :   12027500 :   if (recog_data.operand_type[op_num] != OP_IN)
    1928                 :            :     return -1;
    1929                 :    8888240 :   str = recog_data.constraints[op_num];
    1930                 :    8888240 :   use_commut_op_p = false;
    1931                 :   10232300 :   for (;;)
    1932                 :            :     {
    1933                 :   10232300 :       rtx op = recog_data.operand[op_num];
    1934                 :            :       
    1935                 :   45404400 :       for (curr_alt = 0, ignore_p = !TEST_BIT (alts, curr_alt),
    1936                 :   10232300 :            original = -1;;)
    1937                 :            :         {
    1938                 :   45404400 :           c = *str;
    1939                 :   45404400 :           if (c == '\0')
    1940                 :            :             break;
    1941                 :   42694500 :           if (c == '#')
    1942                 :            :             ignore_p = true;
    1943                 :   42694500 :           else if (c == ',')
    1944                 :            :             {
    1945                 :   11953900 :               curr_alt++;
    1946                 :   11953900 :               ignore_p = !TEST_BIT (alts, curr_alt);
    1947                 :            :             }
    1948                 :   30740600 :           else if (! ignore_p)
    1949                 :   12192900 :             switch (c)
    1950                 :            :               {
    1951                 :        903 :               case 'g':
    1952                 :        903 :                 goto fail;
    1953                 :    9435380 :               default:
    1954                 :    9435380 :                 {
    1955                 :    9435380 :                   enum constraint_num cn = lookup_constraint (str);
    1956                 :    9435380 :                   enum reg_class cl = reg_class_for_constraint (cn);
    1957                 :    7710220 :                   if (cl != NO_REGS
    1958                 :    7710220 :                       && !targetm.class_likely_spilled_p (cl))
    1959                 :    7519280 :                     goto fail;
    1960                 :    1916100 :                   if (constraint_satisfied_p (op, cn))
    1961                 :       2169 :                     goto fail;
    1962                 :            :                   break;
    1963                 :            :                 }
    1964                 :            :                 
    1965                 :    2756660 :               case '0': case '1': case '2': case '3': case '4':
    1966                 :    2756660 :               case '5': case '6': case '7': case '8': case '9':
    1967                 :    2756660 :                 if (original != -1 && original != c)
    1968                 :          0 :                   goto fail;
    1969                 :            :                 original = c;
    1970                 :            :                 break;
    1971                 :            :               }
    1972                 :   35172100 :           str += CONSTRAINT_LEN (c, str);
    1973                 :   35172100 :         }
    1974                 :    2709920 :       if (original == -1)
    1975                 :    1085450 :         goto fail;
    1976                 :    1624470 :       dup = original - '0';
    1977                 :    1624470 :       if (recog_data.operand_type[dup] == OP_OUT)
    1978                 :    1624440 :         return dup;
    1979                 :         32 :     fail:
    1980                 :    8607830 :       if (use_commut_op_p)
    1981                 :            :         break;
    1982                 :    7662700 :       use_commut_op_p = true;
    1983                 :    7662700 :       if (recog_data.constraints[op_num][0] == '%')
    1984                 :     615488 :         str = recog_data.constraints[op_num + 1];
    1985                 :    7047210 :       else if (op_num > 0 && recog_data.constraints[op_num - 1][0] == '%')
    1986                 :            :         str = recog_data.constraints[op_num - 1];
    1987                 :            :       else
    1988                 :            :         break;
    1989                 :            :     }
    1990                 :            :   return -1;
    1991                 :            : }
    1992                 :            : 
    1993                 :            : 
    1994                 :            : 
    1995                 :            : /* Search forward to see if the source register of a copy insn dies
    1996                 :            :    before either it or the destination register is modified, but don't
    1997                 :            :    scan past the end of the basic block.  If so, we can replace the
    1998                 :            :    source with the destination and let the source die in the copy
    1999                 :            :    insn.
    2000                 :            : 
    2001                 :            :    This will reduce the number of registers live in that range and may
    2002                 :            :    enable the destination and the source coalescing, thus often saving
    2003                 :            :    one register in addition to a register-register copy.  */
    2004                 :            : 
    2005                 :            : static void
    2006                 :     944096 : decrease_live_ranges_number (void)
    2007                 :            : {
    2008                 :     944096 :   basic_block bb;
    2009                 :     944096 :   rtx_insn *insn;
    2010                 :     944096 :   rtx set, src, dest, dest_death, note;
    2011                 :     944096 :   rtx_insn *p, *q;
    2012                 :     944096 :   int sregno, dregno;
    2013                 :            : 
    2014                 :     944096 :   if (! flag_expensive_optimizations)
    2015                 :            :     return;
    2016                 :            : 
    2017                 :     645402 :   if (ira_dump_file)
    2018                 :         32 :     fprintf (ira_dump_file, "Starting decreasing number of live ranges...\n");
    2019                 :            : 
    2020                 :    7281180 :   FOR_EACH_BB_FN (bb, cfun)
    2021                 :  160552000 :     FOR_BB_INSNS (bb, insn)
    2022                 :            :       {
    2023                 :   76957900 :         set = single_set (insn);
    2024                 :   76957900 :         if (! set)
    2025                 :   43104800 :           continue;
    2026                 :   33853100 :         src = SET_SRC (set);
    2027                 :   33853100 :         dest = SET_DEST (set);
    2028                 :    9981190 :         if (! REG_P (src) || ! REG_P (dest)
    2029                 :   40244000 :             || find_reg_note (insn, REG_DEAD, src))
    2030                 :   32649000 :           continue;
    2031                 :    1204100 :         sregno = REGNO (src);
    2032                 :    1204100 :         dregno = REGNO (dest);
    2033                 :            :         
    2034                 :            :         /* We don't want to mess with hard regs if register classes
    2035                 :            :            are small.  */
    2036                 :    2181230 :         if (sregno == dregno
    2037                 :    1204100 :             || (targetm.small_register_classes_for_mode_p (GET_MODE (src))
    2038                 :    1204100 :                 && (sregno < FIRST_PSEUDO_REGISTER
    2039                 :    1204100 :                     || dregno < FIRST_PSEUDO_REGISTER))
    2040                 :            :             /* We don't see all updates to SP if they are in an
    2041                 :            :                auto-inc memory reference, so we must disallow this
    2042                 :            :                optimization on them.  */
    2043                 :     226967 :             || sregno == STACK_POINTER_REGNUM
    2044                 :    1431060 :             || dregno == STACK_POINTER_REGNUM)
    2045                 :     977130 :           continue;
    2046                 :            :         
    2047                 :     226967 :         dest_death = NULL_RTX;
    2048                 :            : 
    2049                 :    1605910 :         for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
    2050                 :            :           {
    2051                 :    1603150 :             if (! INSN_P (p))
    2052                 :     402682 :               continue;
    2053                 :    1200470 :             if (BLOCK_FOR_INSN (p) != bb)
    2054                 :            :               break;
    2055                 :            :             
    2056                 :    2020080 :             if (reg_set_p (src, p) || reg_set_p (dest, p)
    2057                 :            :                 /* If SRC is an asm-declared register, it must not be
    2058                 :            :                    replaced in any asm.  Unfortunately, the REG_EXPR
    2059                 :            :                    tree for the asm variable may be absent in the SRC
    2060                 :            :                    rtx, so we can't check the actual register
    2061                 :            :                    declaration easily (the asm operand will have it,
    2062                 :            :                    though).  To avoid complicating the test for a rare
    2063                 :            :                    case, we just don't perform register replacement
    2064                 :            :                    for a hard reg mentioned in an asm.  */
    2065                 :     980723 :                 || (sregno < FIRST_PSEUDO_REGISTER
    2066                 :          0 :                     && asm_noperands (PATTERN (p)) >= 0
    2067                 :          0 :                     && reg_overlap_mentioned_p (src, PATTERN (p)))
    2068                 :            :                 /* Don't change hard registers used by a call.  */
    2069                 :     980723 :                 || (CALL_P (p) && sregno < FIRST_PSEUDO_REGISTER
    2070                 :          0 :                     && find_reg_fusage (p, USE, src))
    2071                 :            :                 /* Don't change a USE of a register.  */
    2072                 :    2000530 :                 || (GET_CODE (PATTERN (p)) == USE
    2073                 :       1074 :                     && reg_overlap_mentioned_p (src, XEXP (PATTERN (p), 0))))
    2074                 :            :               break;
    2075                 :            :             
    2076                 :            :             /* See if all of SRC dies in P.  This test is slightly
    2077                 :            :                more conservative than it needs to be.  */
    2078                 :     980723 :             if ((note = find_regno_note (p, REG_DEAD, sregno))
    2079                 :     980723 :                 && GET_MODE (XEXP (note, 0)) == GET_MODE (src))
    2080                 :            :               {
    2081                 :       4463 :                 int failed = 0;
    2082                 :            :                 
    2083                 :            :                 /* We can do the optimization.  Scan forward from INSN
    2084                 :            :                    again, replacing regs as we go.  Set FAILED if a
    2085                 :            :                    replacement can't be done.  In that case, we can't
    2086                 :            :                    move the death note for SRC.  This should be
    2087                 :            :                    rare.  */
    2088                 :            :                 
    2089                 :            :                 /* Set to stop at next insn.  */
    2090                 :       4463 :                 for (q = next_real_insn (insn);
    2091                 :      38816 :                      q != next_real_insn (p);
    2092                 :      34353 :                      q = next_real_insn (q))
    2093                 :            :                   {
    2094                 :      34353 :                     if (reg_overlap_mentioned_p (src, PATTERN (q)))
    2095                 :            :                       {
    2096                 :            :                         /* If SRC is a hard register, we might miss
    2097                 :            :                            some overlapping registers with
    2098                 :            :                            validate_replace_rtx, so we would have to
    2099                 :            :                            undo it.  We can't if DEST is present in
    2100                 :            :                            the insn, so fail in that combination of
    2101                 :            :                            cases.  */
    2102                 :       6928 :                         if (sregno < FIRST_PSEUDO_REGISTER
    2103                 :       6928 :                             && reg_mentioned_p (dest, PATTERN (q)))
    2104                 :            :                           failed = 1;
    2105                 :            :                         
    2106                 :            :                         /* Attempt to replace all uses.  */
    2107                 :       6928 :                         else if (!validate_replace_rtx (src, dest, q))
    2108                 :            :                           failed = 1;
    2109                 :            :                         
    2110                 :            :                         /* If this succeeded, but some part of the
    2111                 :            :                            register is still present, undo the
    2112                 :            :                            replacement.  */
    2113                 :       6928 :                         else if (sregno < FIRST_PSEUDO_REGISTER
    2114                 :       6928 :                                  && reg_overlap_mentioned_p (src, PATTERN (q)))
    2115                 :            :                           {
    2116                 :          0 :                             validate_replace_rtx (dest, src, q);
    2117                 :          0 :                             failed = 1;
    2118                 :            :                           }
    2119                 :            :                       }
    2120                 :            :                     
    2121                 :            :                     /* If DEST dies here, remove the death note and
    2122                 :            :                        save it for later.  Make sure ALL of DEST dies
    2123                 :            :                        here; again, this is overly conservative.  */
    2124                 :      34353 :                     if (! dest_death
    2125                 :      34353 :                         && (dest_death = find_regno_note (q, REG_DEAD, dregno)))
    2126                 :            :                       {
    2127                 :          1 :                         if (GET_MODE (XEXP (dest_death, 0)) == GET_MODE (dest))
    2128                 :          1 :                           remove_note (q, dest_death);
    2129                 :            :                         else
    2130                 :            :                           {
    2131                 :            :                             failed = 1;
    2132                 :            :                             dest_death = 0;
    2133                 :            :                           }
    2134                 :            :                       }
    2135                 :            :                   }
    2136                 :            :                 
    2137                 :       4463 :                 if (! failed)
    2138                 :            :                   {
    2139                 :            :                     /* Move death note of SRC from P to INSN.  */
    2140                 :       4463 :                     remove_note (p, note);
    2141                 :       4463 :                     XEXP (note, 1) = REG_NOTES (insn);
    2142                 :       4463 :                     REG_NOTES (insn) = note;
    2143                 :            :                   }
    2144                 :            :                 
    2145                 :            :                 /* DEST is also dead if INSN has a REG_UNUSED note for
    2146                 :            :                    DEST.  */
    2147                 :       4463 :                 if (! dest_death
    2148                 :       4463 :                     && (dest_death
    2149                 :       4462 :                         = find_regno_note (insn, REG_UNUSED, dregno)))
    2150                 :            :                   {
    2151                 :          2 :                     PUT_REG_NOTE_KIND (dest_death, REG_DEAD);
    2152                 :          2 :                     remove_note (insn, dest_death);
    2153                 :            :                   }
    2154                 :            :                 
    2155                 :            :                 /* Put death note of DEST on P if we saw it die.  */
    2156                 :       4463 :                 if (dest_death)
    2157                 :            :                   {
    2158                 :          3 :                     XEXP (dest_death, 1) = REG_NOTES (p);
    2159                 :          3 :                     REG_NOTES (p) = dest_death;
    2160                 :            :                   }
    2161                 :            :                 break;
    2162                 :            :               }
    2163                 :            :             
    2164                 :            :             /* If SRC is a hard register which is set or killed in
    2165                 :            :                some other way, we can't do this optimization.  */
    2166                 :     976260 :             else if (sregno < FIRST_PSEUDO_REGISTER && dead_or_set_p (p, src))
    2167                 :            :               break;
    2168                 :            :           }
    2169                 :            :       }
    2170                 :            : }
    2171                 :            : 
    2172                 :            : 
    2173                 :            : 
    2174                 :            : /* Return nonzero if REGNO is a particularly bad choice for reloading X.  */
    2175                 :            : static bool
    2176                 :          0 : ira_bad_reload_regno_1 (int regno, rtx x)
    2177                 :            : {
    2178                 :          0 :   int x_regno, n, i;
    2179                 :          0 :   ira_allocno_t a;
    2180                 :          0 :   enum reg_class pref;
    2181                 :            : 
    2182                 :            :   /* We only deal with pseudo regs.  */
    2183                 :          0 :   if (! x || GET_CODE (x) != REG)
    2184                 :            :     return false;
    2185                 :            : 
    2186                 :          0 :   x_regno = REGNO (x);
    2187                 :          0 :   if (x_regno < FIRST_PSEUDO_REGISTER)
    2188                 :            :     return false;
    2189                 :            : 
    2190                 :            :   /* If the pseudo prefers REGNO explicitly, then do not consider
    2191                 :            :      REGNO a bad spill choice.  */
    2192                 :          0 :   pref = reg_preferred_class (x_regno);
    2193                 :          0 :   if (reg_class_size[pref] == 1)
    2194                 :          0 :     return !TEST_HARD_REG_BIT (reg_class_contents[pref], regno);
    2195                 :            : 
    2196                 :            :   /* If the pseudo conflicts with REGNO, then we consider REGNO a
    2197                 :            :      poor choice for a reload regno.  */
    2198                 :          0 :   a = ira_regno_allocno_map[x_regno];
    2199                 :          0 :   n = ALLOCNO_NUM_OBJECTS (a);
    2200                 :          0 :   for (i = 0; i < n; i++)
    2201                 :            :     {
    2202                 :          0 :       ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2203                 :          0 :       if (TEST_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), regno))
    2204                 :            :         return true;
    2205                 :            :     }
    2206                 :            :   return false;
    2207                 :            : }
    2208                 :            : 
    2209                 :            : /* Return nonzero if REGNO is a particularly bad choice for reloading
    2210                 :            :    IN or OUT.  */
    2211                 :            : bool
    2212                 :          0 : ira_bad_reload_regno (int regno, rtx in, rtx out)
    2213                 :            : {
    2214                 :          0 :   return (ira_bad_reload_regno_1 (regno, in)
    2215                 :          0 :           || ira_bad_reload_regno_1 (regno, out));
    2216                 :            : }
    2217                 :            : 
    2218                 :            : /* Add register clobbers from asm statements.  */
    2219                 :            : static void
    2220                 :     964353 : compute_regs_asm_clobbered (void)
    2221                 :            : {
    2222                 :     964353 :   basic_block bb;
    2223                 :            : 
    2224                 :   10290900 :   FOR_EACH_BB_FN (bb, cfun)
    2225                 :            :     {
    2226                 :    9326530 :       rtx_insn *insn;
    2227                 :  206511000 :       FOR_BB_INSNS_REVERSE (bb, insn)
    2228                 :            :         {
    2229                 :   98592300 :           df_ref def;
    2230                 :            : 
    2231                 :   98592300 :           if (NONDEBUG_INSN_P (insn) && asm_noperands (PATTERN (insn)) >= 0)
    2232                 :     288307 :             FOR_EACH_INSN_DEF (def, insn)
    2233                 :            :               {
    2234                 :     199218 :                 unsigned int dregno = DF_REF_REGNO (def);
    2235                 :     199218 :                 if (HARD_REGISTER_NUM_P (dregno))
    2236                 :     199218 :                   add_to_hard_reg_set (&crtl->asm_clobbers,
    2237                 :     129093 :                                        GET_MODE (DF_REF_REAL_REG (def)),
    2238                 :            :                                        dregno);
    2239                 :            :               }
    2240                 :            :         }
    2241                 :            :     }
    2242                 :     964353 : }
    2243                 :            : 
    2244                 :            : 
    2245                 :            : /* Set up ELIMINABLE_REGSET, IRA_NO_ALLOC_REGS, and
    2246                 :            :    REGS_EVER_LIVE.  */
    2247                 :            : void
    2248                 :     964353 : ira_setup_eliminable_regset (void)
    2249                 :            : {
    2250                 :     964353 :   int i;
    2251                 :     964353 :   static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
    2252                 :    1062280 :   int fp_reg_count = hard_regno_nregs (HARD_FRAME_POINTER_REGNUM, Pmode);
    2253                 :            : 
    2254                 :            :   /* Setup is_leaf as frame_pointer_required may use it.  This function
    2255                 :            :      is called by sched_init before ira if scheduling is enabled.  */
    2256                 :     964353 :   crtl->is_leaf = leaf_function_p ();
    2257                 :            : 
    2258                 :            :   /* FIXME: If EXIT_IGNORE_STACK is set, we will not save and restore
    2259                 :            :      sp for alloca.  So we can't eliminate the frame pointer in that
    2260                 :            :      case.  At some point, we should improve this by emitting the
    2261                 :            :      sp-adjusting insns for this case.  */
    2262                 :     964353 :   frame_pointer_needed
    2263                 :    1928710 :     = (! flag_omit_frame_pointer
    2264                 :     696693 :        || (cfun->calls_alloca && EXIT_IGNORE_STACK)
    2265                 :            :        /* We need the frame pointer to catch stack overflow exceptions if
    2266                 :            :           the stack pointer is moving (as for the alloca case just above).  */
    2267                 :     691626 :        || (STACK_CHECK_MOVING_SP
    2268                 :     691626 :            && flag_stack_check
    2269                 :         30 :            && flag_exceptions
    2270                 :          0 :            && cfun->can_throw_non_call_exceptions)
    2271                 :     691626 :        || crtl->accesses_prior_frames
    2272                 :     776826 :        || (SUPPORTS_STACK_ALIGNMENT && crtl->stack_realign_needed)
    2273                 :    1624020 :        || targetm.frame_pointer_required ());
    2274                 :            : 
    2275                 :            :     /* The chance that FRAME_POINTER_NEEDED is changed from inspecting
    2276                 :            :        RTL is very small.  So if we use frame pointer for RA and RTL
    2277                 :            :        actually prevents this, we will spill pseudos assigned to the
    2278                 :            :        frame pointer in LRA.  */
    2279                 :            : 
    2280                 :     964353 :   if (frame_pointer_needed)
    2281                 :     609466 :     for (i = 0; i < fp_reg_count; i++)
    2282                 :     304733 :       df_set_regs_ever_live (HARD_FRAME_POINTER_REGNUM + i, true);
    2283                 :            :     
    2284                 :     964353 :   ira_no_alloc_regs = no_unit_alloc_regs;
    2285                 :     964353 :   CLEAR_HARD_REG_SET (eliminable_regset);
    2286                 :            : 
    2287                 :     964353 :   compute_regs_asm_clobbered ();
    2288                 :            : 
    2289                 :            :   /* Build the regset of all eliminable registers and show we can't
    2290                 :            :      use those that we already know won't be eliminated.  */
    2291                 :    4821760 :   for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
    2292                 :            :     {
    2293                 :    3857410 :       bool cannot_elim
    2294                 :    3857410 :         = (! targetm.can_eliminate (eliminables[i].from, eliminables[i].to)
    2295                 :    3857410 :            || (eliminables[i].to == STACK_POINTER_REGNUM && frame_pointer_needed));
    2296                 :            : 
    2297                 :    3857410 :       if (!TEST_HARD_REG_BIT (crtl->asm_clobbers, eliminables[i].from))
    2298                 :            :         {
    2299                 :    3857410 :             SET_HARD_REG_BIT (eliminable_regset, eliminables[i].from);
    2300                 :            : 
    2301                 :    3857410 :             if (cannot_elim)
    2302                 :    3857410 :               SET_HARD_REG_BIT (ira_no_alloc_regs, eliminables[i].from);
    2303                 :            :         }
    2304                 :          2 :       else if (cannot_elim)
    2305                 :          1 :         error ("%s cannot be used in %<asm%> here",
    2306                 :            :                reg_names[eliminables[i].from]);
    2307                 :            :       else
    2308                 :          1 :         df_set_regs_ever_live (eliminables[i].from, true);
    2309                 :            :     }
    2310                 :            :   if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
    2311                 :            :     {
    2312                 :    1928710 :       for (i = 0; i < fp_reg_count; i++)
    2313                 :     964353 :         if (!TEST_HARD_REG_BIT (crtl->asm_clobbers,
    2314                 :     964353 :                                 HARD_FRAME_POINTER_REGNUM + i))
    2315                 :            :           {
    2316                 :     963071 :             SET_HARD_REG_BIT (eliminable_regset,
    2317                 :            :                               HARD_FRAME_POINTER_REGNUM + i);
    2318                 :     963071 :             if (frame_pointer_needed)
    2319                 :     964353 :               SET_HARD_REG_BIT (ira_no_alloc_regs,
    2320                 :            :                                 HARD_FRAME_POINTER_REGNUM + i);
    2321                 :            :           }
    2322                 :       1282 :         else if (frame_pointer_needed)
    2323                 :          1 :           error ("%s cannot be used in %<asm%> here",
    2324                 :            :                  reg_names[HARD_FRAME_POINTER_REGNUM + i]);
    2325                 :            :         else
    2326                 :       1281 :           df_set_regs_ever_live (HARD_FRAME_POINTER_REGNUM + i, true);
    2327                 :            :     }
    2328                 :     964353 : }
    2329                 :            : 
    2330                 :            : 
    2331                 :            : 
    2332                 :            : /* Vector of substitutions of register numbers,
    2333                 :            :    used to map pseudo regs into hardware regs.
    2334                 :            :    This is set up as a result of register allocation.
    2335                 :            :    Element N is the hard reg assigned to pseudo reg N,
    2336                 :            :    or is -1 if no hard reg was assigned.
    2337                 :            :    If N is a hard reg number, element N is N.  */
    2338                 :            : short *reg_renumber;
    2339                 :            : 
    2340                 :            : /* Set up REG_RENUMBER and CALLER_SAVE_NEEDED (used by reload) from
    2341                 :            :    the allocation found by IRA.  */
    2342                 :            : static void
    2343                 :     944096 : setup_reg_renumber (void)
    2344                 :            : {
    2345                 :     944096 :   int regno, hard_regno;
    2346                 :     944096 :   ira_allocno_t a;
    2347                 :     944096 :   ira_allocno_iterator ai;
    2348                 :            : 
    2349                 :     944096 :   caller_save_needed = 0;
    2350                 :     944096 :   FOR_EACH_ALLOCNO (a, ai)
    2351                 :            :     {
    2352                 :   22912100 :       if (ira_use_lra_p && ALLOCNO_CAP_MEMBER (a) != NULL)
    2353                 :    2800960 :         continue;
    2354                 :            :       /* There are no caps at this point.  */
    2355                 :   20111200 :       ira_assert (ALLOCNO_CAP_MEMBER (a) == NULL);
    2356                 :   20111200 :       if (! ALLOCNO_ASSIGNED_P (a))
    2357                 :            :         /* It can happen if A is not referenced but partially anticipated
    2358                 :            :            somewhere in a region.  */
    2359                 :          0 :         ALLOCNO_ASSIGNED_P (a) = true;
    2360                 :   20111200 :       ira_free_allocno_updated_costs (a);
    2361                 :   20111200 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2362                 :   20111200 :       regno = ALLOCNO_REGNO (a);
    2363                 :   20111200 :       reg_renumber[regno] = (hard_regno < 0 ? -1 : hard_regno);
    2364                 :   20111200 :       if (hard_regno >= 0)
    2365                 :            :         {
    2366                 :   17285100 :           int i, nwords;
    2367                 :   17285100 :           enum reg_class pclass;
    2368                 :   17285100 :           ira_object_t obj;
    2369                 :            :           
    2370                 :   17285100 :           pclass = ira_pressure_class_translate[REGNO_REG_CLASS (hard_regno)];
    2371                 :   17285100 :           nwords = ALLOCNO_NUM_OBJECTS (a);
    2372                 :   34997800 :           for (i = 0; i < nwords; i++)
    2373                 :            :             {
    2374                 :   17712600 :               obj = ALLOCNO_OBJECT (a, i);
    2375                 :   17712600 :               OBJECT_TOTAL_CONFLICT_HARD_REGS (obj)
    2376                 :   53137900 :                 |= ~reg_class_contents[pclass];
    2377                 :            :             }
    2378                 :   42753000 :           if (ira_need_caller_save_p (a, hard_regno))
    2379                 :            :             {
    2380                 :     170364 :               ira_assert (!optimize || flag_caller_saves
    2381                 :            :                           || (ALLOCNO_CALLS_CROSSED_NUM (a)
    2382                 :            :                               == ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a))
    2383                 :            :                           || regno >= ira_reg_equiv_len
    2384                 :            :                           || ira_equiv_no_lvalue_p (regno));
    2385                 :     170364 :               caller_save_needed = 1;
    2386                 :            :             }
    2387                 :            :         }
    2388                 :            :     }
    2389                 :     944096 : }
    2390                 :            : 
    2391                 :            : /* Set up allocno assignment flags for further allocation
    2392                 :            :    improvements.  */
    2393                 :            : static void
    2394                 :          0 : setup_allocno_assignment_flags (void)
    2395                 :            : {
    2396                 :          0 :   int hard_regno;
    2397                 :          0 :   ira_allocno_t a;
    2398                 :          0 :   ira_allocno_iterator ai;
    2399                 :            : 
    2400                 :          0 :   FOR_EACH_ALLOCNO (a, ai)
    2401                 :            :     {
    2402                 :          0 :       if (! ALLOCNO_ASSIGNED_P (a))
    2403                 :            :         /* It can happen if A is not referenced but partially anticipated
    2404                 :            :            somewhere in a region.  */
    2405                 :          0 :         ira_free_allocno_updated_costs (a);
    2406                 :          0 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2407                 :            :       /* Don't assign hard registers to allocnos which are destination
    2408                 :            :          of removed store at the end of loop.  It has no sense to keep
    2409                 :            :          the same value in different hard registers.  It is also
    2410                 :            :          impossible to assign hard registers correctly to such
    2411                 :            :          allocnos because the cost info and info about intersected
    2412                 :            :          calls are incorrect for them.  */
    2413                 :          0 :       ALLOCNO_ASSIGNED_P (a) = (hard_regno >= 0
    2414                 :          0 :                                 || ALLOCNO_EMIT_DATA (a)->mem_optimized_dest_p
    2415                 :          0 :                                 || (ALLOCNO_MEMORY_COST (a)
    2416                 :          0 :                                     - ALLOCNO_CLASS_COST (a)) < 0);
    2417                 :          0 :       ira_assert
    2418                 :            :         (hard_regno < 0
    2419                 :            :          || ira_hard_reg_in_set_p (hard_regno, ALLOCNO_MODE (a),
    2420                 :            :                                    reg_class_contents[ALLOCNO_CLASS (a)]));
    2421                 :            :     }
    2422                 :          0 : }
    2423                 :            : 
    2424                 :            : /* Evaluate overall allocation cost and the costs for using hard
    2425                 :            :    registers and memory for allocnos.  */
    2426                 :            : static void
    2427                 :     944096 : calculate_allocation_cost (void)
    2428                 :            : {
    2429                 :     944096 :   int hard_regno, cost;
    2430                 :     944096 :   ira_allocno_t a;
    2431                 :     944096 :   ira_allocno_iterator ai;
    2432                 :            : 
    2433                 :     944096 :   ira_overall_cost = ira_reg_cost = ira_mem_cost = 0;
    2434                 :   23856200 :   FOR_EACH_ALLOCNO (a, ai)
    2435                 :            :     {
    2436                 :   22912100 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2437                 :   22912100 :       ira_assert (hard_regno < 0
    2438                 :            :                   || (ira_hard_reg_in_set_p
    2439                 :            :                       (hard_regno, ALLOCNO_MODE (a),
    2440                 :            :                        reg_class_contents[ALLOCNO_CLASS (a)])));
    2441                 :   22912100 :       if (hard_regno < 0)
    2442                 :            :         {
    2443                 :    3253760 :           cost = ALLOCNO_MEMORY_COST (a);
    2444                 :    3253760 :           ira_mem_cost += cost;
    2445                 :            :         }
    2446                 :   19658400 :       else if (ALLOCNO_HARD_REG_COSTS (a) != NULL)
    2447                 :            :         {
    2448                 :    6083340 :           cost = (ALLOCNO_HARD_REG_COSTS (a)
    2449                 :            :                   [ira_class_hard_reg_index
    2450                 :    6083340 :                    [ALLOCNO_CLASS (a)][hard_regno]]);
    2451                 :    6083340 :           ira_reg_cost += cost;
    2452                 :            :         }
    2453                 :            :       else
    2454                 :            :         {
    2455                 :   13575000 :           cost = ALLOCNO_CLASS_COST (a);
    2456                 :   13575000 :           ira_reg_cost += cost;
    2457                 :            :         }
    2458                 :   22912100 :       ira_overall_cost += cost;
    2459                 :            :     }
    2460                 :            : 
    2461                 :     944096 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    2462                 :            :     {
    2463                 :        102 :       fprintf (ira_dump_file,
    2464                 :            :                "+++Costs: overall %" PRId64
    2465                 :            :                ", reg %" PRId64
    2466                 :            :                ", mem %" PRId64
    2467                 :            :                ", ld %" PRId64
    2468                 :            :                ", st %" PRId64
    2469                 :            :                ", move %" PRId64,
    2470                 :            :                ira_overall_cost, ira_reg_cost, ira_mem_cost,
    2471                 :            :                ira_load_cost, ira_store_cost, ira_shuffle_cost);
    2472                 :        102 :       fprintf (ira_dump_file, "\n+++       move loops %d, new jumps %d\n",
    2473                 :            :                ira_move_loops_num, ira_additional_jumps_num);
    2474                 :            :     }
    2475                 :            : 
    2476                 :     944096 : }
    2477                 :            : 
    2478                 :            : #ifdef ENABLE_IRA_CHECKING
    2479                 :            : /* Check the correctness of the allocation.  We do need this because
    2480                 :            :    of complicated code to transform more one region internal
    2481                 :            :    representation into one region representation.  */
    2482                 :            : static void
    2483                 :          0 : check_allocation (void)
    2484                 :            : {
    2485                 :          0 :   ira_allocno_t a;
    2486                 :          0 :   int hard_regno, nregs, conflict_nregs;
    2487                 :          0 :   ira_allocno_iterator ai;
    2488                 :            : 
    2489                 :          0 :   FOR_EACH_ALLOCNO (a, ai)
    2490                 :            :     {
    2491                 :          0 :       int n = ALLOCNO_NUM_OBJECTS (a);
    2492                 :          0 :       int i;
    2493                 :            : 
    2494                 :          0 :       if (ALLOCNO_CAP_MEMBER (a) != NULL
    2495                 :          0 :           || (hard_regno = ALLOCNO_HARD_REGNO (a)) < 0)
    2496                 :          0 :         continue;
    2497                 :          0 :       nregs = hard_regno_nregs (hard_regno, ALLOCNO_MODE (a));
    2498                 :          0 :       if (nregs == 1)
    2499                 :            :         /* We allocated a single hard register.  */
    2500                 :            :         n = 1;
    2501                 :          0 :       else if (n > 1)
    2502                 :            :         /* We allocated multiple hard registers, and we will test
    2503                 :            :            conflicts in a granularity of single hard regs.  */
    2504                 :          0 :         nregs = 1;
    2505                 :            : 
    2506                 :          0 :       for (i = 0; i < n; i++)
    2507                 :            :         {
    2508                 :          0 :           ira_object_t obj = ALLOCNO_OBJECT (a, i);
    2509                 :          0 :           ira_object_t conflict_obj;
    2510                 :          0 :           ira_object_conflict_iterator oci;
    2511                 :          0 :           int this_regno = hard_regno;
    2512                 :          0 :           if (n > 1)
    2513                 :            :             {
    2514                 :          0 :               if (REG_WORDS_BIG_ENDIAN)
    2515                 :            :                 this_regno += n - i - 1;
    2516                 :            :               else
    2517                 :          0 :                 this_regno += i;
    2518                 :            :             }
    2519                 :          0 :           FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
    2520                 :            :             {
    2521                 :          0 :               ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj);
    2522                 :          0 :               int conflict_hard_regno = ALLOCNO_HARD_REGNO (conflict_a);
    2523                 :          0 :               if (conflict_hard_regno < 0)
    2524                 :          0 :                 continue;
    2525                 :            : 
    2526                 :          0 :               conflict_nregs = hard_regno_nregs (conflict_hard_regno,
    2527                 :          0 :                                                  ALLOCNO_MODE (conflict_a));
    2528                 :            : 
    2529                 :          0 :               if (ALLOCNO_NUM_OBJECTS (conflict_a) > 1
    2530                 :          0 :                   && conflict_nregs == ALLOCNO_NUM_OBJECTS (conflict_a))
    2531                 :            :                 {
    2532                 :          0 :                   if (REG_WORDS_BIG_ENDIAN)
    2533                 :            :                     conflict_hard_regno += (ALLOCNO_NUM_OBJECTS (conflict_a)
    2534                 :            :                                             - OBJECT_SUBWORD (conflict_obj) - 1);
    2535                 :            :                   else
    2536                 :          0 :                     conflict_hard_regno += OBJECT_SUBWORD (conflict_obj);
    2537                 :          0 :                   conflict_nregs = 1;
    2538                 :            :                 }
    2539                 :            : 
    2540                 :          0 :               if ((conflict_hard_regno <= this_regno
    2541                 :          0 :                  && this_regno < conflict_hard_regno + conflict_nregs)
    2542                 :          0 :                 || (this_regno <= conflict_hard_regno
    2543                 :          0 :                     && conflict_hard_regno < this_regno + nregs))
    2544                 :            :                 {
    2545                 :          0 :                   fprintf (stderr, "bad allocation for %d and %d\n",
    2546                 :            :                            ALLOCNO_REGNO (a), ALLOCNO_REGNO (conflict_a));
    2547                 :          0 :                   gcc_unreachable ();
    2548                 :            :                 }
    2549                 :            :             }
    2550                 :            :         }
    2551                 :            :     }
    2552                 :          0 : }
    2553                 :            : #endif
    2554                 :            : 
    2555                 :            : /* Allocate REG_EQUIV_INIT.  Set up it from IRA_REG_EQUIV which should
    2556                 :            :    be already calculated.  */
    2557                 :            : static void
    2558                 :     944096 : setup_reg_equiv_init (void)
    2559                 :            : {
    2560                 :     944096 :   int i;
    2561                 :     944096 :   int max_regno = max_reg_num ();
    2562                 :            : 
    2563                 :  112830000 :   for (i = 0; i < max_regno; i++)
    2564                 :  111886000 :     reg_equiv_init (i) = ira_reg_equiv[i].init_insns;
    2565                 :     944096 : }
    2566                 :            : 
    2567                 :            : /* Update equiv regno from movement of FROM_REGNO to TO_REGNO.  INSNS
    2568                 :            :    are insns which were generated for such movement.  It is assumed
    2569                 :            :    that FROM_REGNO and TO_REGNO always have the same value at the
    2570                 :            :    point of any move containing such registers. This function is used
    2571                 :            :    to update equiv info for register shuffles on the region borders
    2572                 :            :    and for caller save/restore insns.  */
    2573                 :            : void
    2574                 :    1107200 : ira_update_equiv_info_by_shuffle_insn (int to_regno, int from_regno, rtx_insn *insns)
    2575                 :            : {
    2576                 :    1107200 :   rtx_insn *insn;
    2577                 :    1107200 :   rtx x, note;
    2578                 :            : 
    2579                 :    1107200 :   if (! ira_reg_equiv[from_regno].defined_p
    2580                 :    1107200 :       && (! ira_reg_equiv[to_regno].defined_p
    2581                 :        582 :           || ((x = ira_reg_equiv[to_regno].memory) != NULL_RTX
    2582                 :        582 :               && ! MEM_READONLY_P (x))))
    2583                 :            :     return;
    2584                 :      27570 :   insn = insns;
    2585                 :      27570 :   if (NEXT_INSN (insn) != NULL_RTX)
    2586                 :            :     {
    2587                 :          0 :       if (! ira_reg_equiv[to_regno].defined_p)
    2588                 :            :         {
    2589                 :          0 :           ira_assert (ira_reg_equiv[to_regno].init_insns == NULL_RTX);
    2590                 :            :           return;
    2591                 :            :         }
    2592                 :          0 :       ira_reg_equiv[to_regno].defined_p = false;
    2593                 :          0 :       ira_reg_equiv[to_regno].memory
    2594                 :          0 :         = ira_reg_equiv[to_regno].constant
    2595                 :          0 :         = ira_reg_equiv[to_regno].invariant
    2596                 :          0 :         = ira_reg_equiv[to_regno].init_insns = NULL;
    2597                 :          0 :       if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2598                 :          0 :         fprintf (ira_dump_file,
    2599                 :            :                  "      Invalidating equiv info for reg %d\n", to_regno);
    2600                 :          0 :       return;
    2601                 :            :     }
    2602                 :            :   /* It is possible that FROM_REGNO still has no equivalence because
    2603                 :            :      in shuffles to_regno<-from_regno and from_regno<-to_regno the 2nd
    2604                 :            :      insn was not processed yet.  */
    2605                 :      27570 :   if (ira_reg_equiv[from_regno].defined_p)
    2606                 :            :     {
    2607                 :      27570 :       ira_reg_equiv[to_regno].defined_p = true;
    2608                 :      27570 :       if ((x = ira_reg_equiv[from_regno].memory) != NULL_RTX)
    2609                 :            :         {
    2610                 :      27489 :           ira_assert (ira_reg_equiv[from_regno].invariant == NULL_RTX
    2611                 :            :                       && ira_reg_equiv[from_regno].constant == NULL_RTX);
    2612                 :      27489 :           ira_assert (ira_reg_equiv[to_regno].memory == NULL_RTX
    2613                 :            :                       || rtx_equal_p (ira_reg_equiv[to_regno].memory, x));
    2614                 :      27489 :           ira_reg_equiv[to_regno].memory = x;
    2615                 :      27489 :           if (! MEM_READONLY_P (x))
    2616                 :            :             /* We don't add the insn to insn init list because memory
    2617                 :            :                equivalence is just to say what memory is better to use
    2618                 :            :                when the pseudo is spilled.  */
    2619                 :            :             return;
    2620                 :            :         }
    2621                 :         81 :       else if ((x = ira_reg_equiv[from_regno].constant) != NULL_RTX)
    2622                 :            :         {
    2623                 :         18 :           ira_assert (ira_reg_equiv[from_regno].invariant == NULL_RTX);
    2624                 :         18 :           ira_assert (ira_reg_equiv[to_regno].constant == NULL_RTX
    2625                 :            :                       || rtx_equal_p (ira_reg_equiv[to_regno].constant, x));
    2626                 :         18 :           ira_reg_equiv[to_regno].constant = x;
    2627                 :            :         }
    2628                 :            :       else
    2629                 :            :         {
    2630                 :         63 :           x = ira_reg_equiv[from_regno].invariant;
    2631                 :         63 :           ira_assert (x != NULL_RTX);
    2632                 :         63 :           ira_assert (ira_reg_equiv[to_regno].invariant == NULL_RTX
    2633                 :            :                       || rtx_equal_p (ira_reg_equiv[to_regno].invariant, x));
    2634                 :         63 :           ira_reg_equiv[to_regno].invariant = x;
    2635                 :            :         }
    2636                 :         90 :       if (find_reg_note (insn, REG_EQUIV, x) == NULL_RTX)
    2637                 :            :         {
    2638                 :         90 :           note = set_unique_reg_note (insn, REG_EQUIV, copy_rtx (x));
    2639                 :         90 :           gcc_assert (note != NULL_RTX);
    2640                 :         90 :           if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2641                 :            :             {
    2642                 :          0 :               fprintf (ira_dump_file,
    2643                 :            :                        "      Adding equiv note to insn %u for reg %d ",
    2644                 :          0 :                        INSN_UID (insn), to_regno);
    2645                 :          0 :               dump_value_slim (ira_dump_file, x, 1);
    2646                 :          0 :               fprintf (ira_dump_file, "\n");
    2647                 :            :             }
    2648                 :            :         }
    2649                 :            :     }
    2650                 :         90 :   ira_reg_equiv[to_regno].init_insns
    2651                 :        180 :     = gen_rtx_INSN_LIST (VOIDmode, insn,
    2652                 :         90 :                          ira_reg_equiv[to_regno].init_insns);
    2653                 :         90 :   if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL)
    2654                 :          0 :     fprintf (ira_dump_file,
    2655                 :            :              "      Adding equiv init move insn %u to reg %d\n",
    2656                 :          0 :              INSN_UID (insn), to_regno);
    2657                 :            : }
    2658                 :            : 
    2659                 :            : /* Fix values of array REG_EQUIV_INIT after live range splitting done
    2660                 :            :    by IRA.  */
    2661                 :            : static void
    2662                 :    1377100 : fix_reg_equiv_init (void)
    2663                 :            : {
    2664                 :    1377100 :   int max_regno = max_reg_num ();
    2665                 :    1377100 :   int i, new_regno, max;
    2666                 :    1377100 :   rtx set;
    2667                 :    1377100 :   rtx_insn_list *x, *next, *prev;
    2668                 :    1377100 :   rtx_insn *insn;
    2669                 :            : 
    2670                 :    1377100 :   if (max_regno_before_ira < max_regno)
    2671                 :            :     {
    2672                 :     345135 :       max = vec_safe_length (reg_equivs);
    2673                 :     345135 :       grow_reg_equivs ();
    2674                 :   30425600 :       for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
    2675                 :   30080500 :         for (prev = NULL, x = reg_equiv_init (i);
    2676                 :   32800300 :              x != NULL_RTX;
    2677                 :            :              x = next)
    2678                 :            :           {
    2679                 :    2719810 :             next = x->next ();
    2680                 :    2719810 :             insn = x->insn ();
    2681                 :    2719810 :             set = single_set (insn);
    2682                 :    2719810 :             ira_assert (set != NULL_RTX
    2683                 :            :                         && (REG_P (SET_DEST (set)) || REG_P (SET_SRC (set))));
    2684                 :    2719810 :             if (REG_P (SET_DEST (set))
    2685                 :    2719810 :                 && ((int) REGNO (SET_DEST (set)) == i
    2686                 :          0 :                     || (int) ORIGINAL_REGNO (SET_DEST (set)) == i))
    2687                 :            :               new_regno = REGNO (SET_DEST (set));
    2688                 :     278372 :             else if (REG_P (SET_SRC (set))
    2689                 :     278372 :                      && ((int) REGNO (SET_SRC (set)) == i
    2690                 :          0 :                          || (int) ORIGINAL_REGNO (SET_SRC (set)) == i))
    2691                 :            :               new_regno = REGNO (SET_SRC (set));
    2692                 :            :             else
    2693                 :          0 :               gcc_unreachable ();
    2694                 :    2719810 :             if (new_regno == i)
    2695                 :            :               prev = x;
    2696                 :            :             else
    2697                 :            :               {
    2698                 :            :                 /* Remove the wrong list element.  */
    2699                 :          0 :                 if (prev == NULL_RTX)
    2700                 :          0 :                   reg_equiv_init (i) = next;
    2701                 :            :                 else
    2702                 :          0 :                   XEXP (prev, 1) = next;
    2703                 :          0 :                 XEXP (x, 1) = reg_equiv_init (new_regno);
    2704                 :          0 :                 reg_equiv_init (new_regno) = x;
    2705                 :            :               }
    2706                 :            :           }
    2707                 :            :     }
    2708                 :    1377100 : }
    2709                 :            : 
    2710                 :            : #ifdef ENABLE_IRA_CHECKING
    2711                 :            : /* Print redundant memory-memory copies.  */
    2712                 :            : static void
    2713                 :     688548 : print_redundant_copies (void)
    2714                 :            : {
    2715                 :     688548 :   int hard_regno;
    2716                 :     688548 :   ira_allocno_t a;
    2717                 :     688548 :   ira_copy_t cp, next_cp;
    2718                 :     688548 :   ira_allocno_iterator ai;
    2719                 :            : 
    2720                 :   17645500 :   FOR_EACH_ALLOCNO (a, ai)
    2721                 :            :     {
    2722                 :   16956900 :       if (ALLOCNO_CAP_MEMBER (a) != NULL)
    2723                 :            :         /* It is a cap.  */
    2724                 :    2800960 :         continue;
    2725                 :   14156000 :       hard_regno = ALLOCNO_HARD_REGNO (a);
    2726                 :   14156000 :       if (hard_regno >= 0)
    2727                 :   11399800 :         continue;
    2728                 :    3267830 :       for (cp = ALLOCNO_COPIES (a); cp != NULL; cp = next_cp)
    2729                 :     511639 :         if (cp->first == a)
    2730                 :     241750 :           next_cp = cp->next_first_allocno_copy;
    2731                 :            :         else
    2732                 :            :           {
    2733                 :     269889 :             next_cp = cp->next_second_allocno_copy;
    2734                 :     269889 :             if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL
    2735                 :         33 :                 && cp->insn != NULL_RTX
    2736                 :          0 :                 && ALLOCNO_HARD_REGNO (cp->first) == hard_regno)
    2737                 :          0 :               fprintf (ira_dump_file,
    2738                 :            :                        "        Redundant move from %d(freq %d):%d\n",
    2739                 :          0 :                        INSN_UID (cp->insn), cp->freq, hard_regno);
    2740                 :            :           }
    2741                 :            :     }
    2742                 :     688548 : }
    2743                 :            : #endif
    2744                 :            : 
    2745                 :            : /* Setup preferred and alternative classes for new pseudo-registers
    2746                 :            :    created by IRA starting with START.  */
    2747                 :            : static void
    2748                 :     713968 : setup_preferred_alternate_classes_for_new_pseudos (int start)
    2749                 :            : {
    2750                 :     713968 :   int i, old_regno;
    2751                 :     713968 :   int max_regno = max_reg_num ();
    2752                 :            : 
    2753                 :    1376200 :   for (i = start; i < max_regno; i++)
    2754                 :            :     {
    2755                 :     662228 :       old_regno = ORIGINAL_REGNO (regno_reg_rtx[i]);
    2756                 :     662228 :       ira_assert (i != old_regno);
    2757                 :     662228 :       setup_reg_classes (i, reg_preferred_class (old_regno),
    2758                 :            :                          reg_alternate_class (old_regno),
    2759                 :            :                          reg_allocno_class (old_regno));
    2760                 :     662228 :       if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
    2761                 :          0 :         fprintf (ira_dump_file,
    2762                 :            :                  "    New r%d: setting preferred %s, alternative %s\n",
    2763                 :          0 :                  i, reg_class_names[reg_preferred_class (old_regno)],
    2764                 :          0 :                  reg_class_names[reg_alternate_class (old_regno)]);
    2765                 :            :     }
    2766                 :     713968 : }
    2767                 :            : 
    2768                 :            : 
    2769                 :            : /* The number of entries allocated in reg_info.  */
    2770                 :            : static int allocated_reg_info_size;
    2771                 :            : 
    2772                 :            : /* Regional allocation can create new pseudo-registers.  This function
    2773                 :            :    expands some arrays for pseudo-registers.  */
    2774                 :            : static void
    2775                 :     713968 : expand_reg_info (void)
    2776                 :            : {
    2777                 :     713968 :   int i;
    2778                 :     713968 :   int size = max_reg_num ();
    2779                 :            : 
    2780                 :     713968 :   resize_reg_info ();
    2781                 :    1376200 :   for (i = allocated_reg_info_size; i < size; i++)
    2782                 :     662228 :     setup_reg_classes (i, GENERAL_REGS, ALL_REGS, GENERAL_REGS);
    2783                 :     713968 :   setup_preferred_alternate_classes_for_new_pseudos (allocated_reg_info_size);
    2784                 :     713968 :   allocated_reg_info_size = size;
    2785                 :     713968 : }
    2786                 :            : 
    2787                 :            : /* Return TRUE if there is too high register pressure in the function.
    2788                 :            :    It is used to decide when stack slot sharing is worth to do.  */
    2789                 :            : static bool
    2790                 :     944096 : too_high_register_pressure_p (void)
    2791                 :            : {
    2792                 :     944096 :   int i;
    2793                 :     944096 :   enum reg_class pclass;
    2794                 :            : 
    2795                 :    4746620 :   for (i = 0; i < ira_pressure_classes_num; i++)
    2796                 :            :     {
    2797                 :    3802520 :       pclass = ira_pressure_classes[i];
    2798                 :    3802520 :       if (ira_loop_tree_root->reg_pressure[pclass] > 10000)
    2799                 :            :         return true;
    2800                 :            :     }
    2801                 :            :   return false;
    2802                 :            : }
    2803                 :            : 
    2804                 :            : 
    2805                 :            : 
    2806                 :            : /* Indicate that hard register number FROM was eliminated and replaced with
    2807                 :            :    an offset from hard register number TO.  The status of hard registers live
    2808                 :            :    at the start of a basic block is updated by replacing a use of FROM with
    2809                 :            :    a use of TO.  */
    2810                 :            : 
    2811                 :            : void
    2812                 :          0 : mark_elimination (int from, int to)
    2813                 :            : {
    2814                 :          0 :   basic_block bb;
    2815                 :          0 :   bitmap r;
    2816                 :            : 
    2817                 :          0 :   FOR_EACH_BB_FN (bb, cfun)
    2818                 :            :     {
    2819                 :          0 :       r = DF_LR_IN (bb);
    2820                 :          0 :       if (bitmap_bit_p (r, from))
    2821                 :            :         {
    2822                 :          0 :           bitmap_clear_bit (r, from);
    2823                 :          0 :           bitmap_set_bit (r, to);
    2824                 :            :         }
    2825                 :          0 :       if (! df_live)
    2826                 :          0 :         continue;
    2827                 :          0 :       r = DF_LIVE_IN (bb);
    2828                 :          0 :       if (bitmap_bit_p (r, from))
    2829                 :            :         {
    2830                 :          0 :           bitmap_clear_bit (r, from);
    2831                 :          0 :           bitmap_set_bit (r, to);
    2832                 :            :         }
    2833                 :            :     }
    2834                 :          0 : }
    2835                 :            : 
    2836                 :            : 
    2837                 :            : 
    2838                 :            : /* The length of the following array.  */
    2839                 :            : int ira_reg_equiv_len;
    2840                 :            : 
    2841                 :            : /* Info about equiv. info for each register.  */
    2842                 :            : struct ira_reg_equiv_s *ira_reg_equiv;
    2843                 :            : 
    2844                 :            : /* Expand ira_reg_equiv if necessary.  */
    2845                 :            : void
    2846                 :    7849000 : ira_expand_reg_equiv (void)
    2847                 :            : {
    2848                 :    7849000 :   int old = ira_reg_equiv_len;
    2849                 :            : 
    2850                 :    7849000 :   if (ira_reg_equiv_len > max_reg_num ())
    2851                 :            :     return;
    2852                 :     947361 :   ira_reg_equiv_len = max_reg_num () * 3 / 2 + 1;
    2853                 :     947361 :   ira_reg_equiv
    2854                 :    1894720 :     = (struct ira_reg_equiv_s *) xrealloc (ira_reg_equiv,
    2855                 :     947361 :                                          ira_reg_equiv_len
    2856                 :            :                                          * sizeof (struct ira_reg_equiv_s));
    2857                 :     947361 :   gcc_assert (old < ira_reg_equiv_len);
    2858                 :     947361 :   memset (ira_reg_equiv + old, 0,
    2859                 :     947361 :           sizeof (struct ira_reg_equiv_s) * (ira_reg_equiv_len - old));
    2860                 :            : }
    2861                 :            : 
    2862                 :            : static void
    2863                 :     944096 : init_reg_equiv (void)
    2864                 :            : {
    2865                 :     944096 :   ira_reg_equiv_len = 0;
    2866                 :     944096 :   ira_reg_equiv = NULL;
    2867                 :          0 :   ira_expand_reg_equiv ();
    2868                 :          0 : }
    2869                 :            : 
    2870                 :            : static void
    2871                 :     944096 : finish_reg_equiv (void)
    2872                 :            : {
    2873                 :     944096 :   free (ira_reg_equiv);
    2874                 :          0 : }
    2875                 :            : 
    2876                 :            : 
    2877                 :            : 
    2878                 :            : struct equivalence
    2879                 :            : {
    2880                 :            :   /* Set when a REG_EQUIV note is found or created.  Use to
    2881                 :            :      keep track of what memory accesses might be created later,
    2882                 :            :      e.g. by reload.  */
    2883                 :            :   rtx replacement;
    2884                 :            :   rtx *src_p;
    2885                 :            : 
    2886                 :            :   /* The list of each instruction which initializes this register.
    2887                 :            : 
    2888                 :            :      NULL indicates we know nothing about this register's equivalence
    2889                 :            :      properties.
    2890                 :            : 
    2891                 :            :      An INSN_LIST with a NULL insn indicates this pseudo is already
    2892                 :            :      known to not have a valid equivalence.  */
    2893                 :            :   rtx_insn_list *init_insns;
    2894                 :            : 
    2895                 :            :   /* Loop depth is used to recognize equivalences which appear
    2896                 :            :      to be present within the same loop (or in an inner loop).  */
    2897                 :            :   short loop_depth;
    2898                 :            :   /* Nonzero if this had a preexisting REG_EQUIV note.  */
    2899                 :            :   unsigned char is_arg_equivalence : 1;
    2900                 :            :   /* Set when an attempt should be made to replace a register
    2901                 :            :      with the associated src_p entry.  */
    2902                 :            :   unsigned char replace : 1;
    2903                 :            :   /* Set if this register has no known equivalence.  */
    2904                 :            :   unsigned char no_equiv : 1;
    2905                 :            :   /* Set if this register is mentioned in a paradoxical subreg.  */
    2906                 :            :   unsigned char pdx_subregs : 1;
    2907                 :            : };
    2908                 :            : 
    2909                 :            : /* reg_equiv[N] (where N is a pseudo reg number) is the equivalence
    2910                 :            :    structure for that register.  */
    2911                 :            : static struct equivalence *reg_equiv;
    2912                 :            : 
    2913                 :            : /* Used for communication between the following two functions.  */
    2914                 :            : struct equiv_mem_data
    2915                 :            : {
    2916                 :            :   /* A MEM that we wish to ensure remains unchanged.  */
    2917                 :            :   rtx equiv_mem;
    2918                 :            : 
    2919                 :            :   /* Set true if EQUIV_MEM is modified.  */
    2920                 :            :   bool equiv_mem_modified;
    2921                 :            : };
    2922                 :            : 
    2923                 :            : /* If EQUIV_MEM is modified by modifying DEST, indicate that it is modified.
    2924                 :            :    Called via note_stores.  */
    2925                 :            : static void
    2926                 :    9917030 : validate_equiv_mem_from_store (rtx dest, const_rtx set ATTRIBUTE_UNUSED,
    2927                 :            :                                void *data)
    2928                 :            : {
    2929                 :    9917030 :   struct equiv_mem_data *info = (struct equiv_mem_data *) data;
    2930                 :            : 
    2931                 :    9917030 :   if ((REG_P (dest)
    2932                 :    6826640 :        && reg_overlap_mentioned_p (dest, info->equiv_mem))
    2933                 :   16735600 :       || (MEM_P (dest)
    2934                 :    3057040 :           && anti_dependence (info->equiv_mem, dest)))
    2935                 :     175333 :     info->equiv_mem_modified = true;
    2936                 :    9917030 : }
    2937                 :            : 
    2938                 :            : enum valid_equiv { valid_none, valid_combine, valid_reload };
    2939                 :            : 
    2940                 :            : /* Verify that no store between START and the death of REG invalidates
    2941                 :            :    MEMREF.  MEMREF is invalidated by modifying a register used in MEMREF,
    2942                 :            :    by storing into an overlapping memory location, or with a non-const
    2943                 :            :    CALL_INSN.
    2944                 :            : 
    2945                 :            :    Return VALID_RELOAD if MEMREF remains valid for both reload and
    2946                 :            :    combine_and_move insns, VALID_COMBINE if only valid for
    2947                 :            :    combine_and_move_insns, and VALID_NONE otherwise.  */
    2948                 :            : static enum valid_equiv
    2949                 :    2411830 : validate_equiv_mem (rtx_insn *start, rtx reg, rtx memref)
    2950                 :            : {
    2951                 :    2411830 :   rtx_insn *insn;
    2952                 :    2411830 :   rtx note;
    2953                 :    2411830 :   struct equiv_mem_data info = { memref, false };
    2954                 :    2411830 :   enum valid_equiv ret = valid_reload;
    2955                 :            : 
    2956                 :            :   /* If the memory reference has side effects or is volatile, it isn't a
    2957                 :            :      valid equivalence.  */
    2958                 :    2411830 :   if (side_effects_p (memref))
    2959                 :            :     return valid_none;
    2960                 :            : 
    2961                 :   27893300 :   for (insn = start; insn; insn = NEXT_INSN (insn))
    2962                 :            :     {
    2963                 :   15081500 :       if (!INSN_P (insn))
    2964                 :    1208810 :         continue;
    2965                 :            : 
    2966                 :   13872700 :       if (find_reg_note (insn, REG_DEAD, reg))
    2967                 :    1685280 :         return ret;
    2968                 :            : 
    2969                 :   12187500 :       if (CALL_P (insn))
    2970                 :            :         {
    2971                 :            :           /* We can combine a reg def from one insn into a reg use in
    2972                 :            :              another over a call if the memory is readonly or the call
    2973                 :            :              const/pure.  However, we can't set reg_equiv notes up for
    2974                 :            :              reload over any call.  The problem is the equivalent form
    2975                 :            :              may reference a pseudo which gets assigned a call
    2976                 :            :              clobbered hard reg.  When we later replace REG with its
    2977                 :            :              equivalent form, the value in the call-clobbered reg has
    2978                 :            :              been changed and all hell breaks loose.  */
    2979                 :     105616 :           ret = valid_combine;
    2980                 :     105616 :           if (!MEM_READONLY_P (memref)
    2981                 :     105616 :               && !RTL_CONST_OR_PURE_CALL_P (insn))
    2982                 :            :             return valid_none;
    2983                 :            :         }
    2984                 :            : 
    2985                 :   12106600 :       note_stores (insn, validate_equiv_mem_from_store, &info);
    2986                 :   12106600 :       if (info.equiv_mem_modified)
    2987                 :            :         return valid_none;
    2988                 :            : 
    2989                 :            :       /* If a register mentioned in MEMREF is modified via an
    2990                 :            :          auto-increment, we lose the equivalence.  Do the same if one
    2991                 :            :          dies; although we could extend the life, it doesn't seem worth
    2992                 :            :          the trouble.  */
    2993                 :            : 
    2994                 :   16494700 :       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    2995                 :    4892010 :         if ((REG_NOTE_KIND (note) == REG_INC
    2996                 :    4892010 :              || REG_NOTE_KIND (note) == REG_DEAD)
    2997                 :    3729160 :             && REG_P (XEXP (note, 0))
    2998                 :    8621170 :             && reg_overlap_mentioned_p (XEXP (note, 0), memref))
    2999                 :            :           return valid_none;
    3000                 :            :     }
    3001                 :            : 
    3002                 :            :   return valid_none;
    3003                 :            : }
    3004                 :            : 
    3005                 :            : /* Returns zero if X is known to be invariant.  */
    3006                 :            : static int
    3007                 :     360943 : equiv_init_varies_p (rtx x)
    3008                 :            : {
    3009                 :     360943 :   RTX_CODE code = GET_CODE (x);
    3010                 :     360943 :   int i;
    3011                 :     360943 :   const char *fmt;
    3012                 :            : 
    3013                 :     360943 :   switch (code)
    3014                 :            :     {
    3015                 :     112075 :     case MEM:
    3016                 :     112075 :       return !MEM_READONLY_P (x) || equiv_init_varies_p (XEXP (x, 0));
    3017                 :            : 
    3018                 :            :     case CONST:
    3019                 :            :     CASE_CONST_ANY:
    3020                 :            :     case SYMBOL_REF:
    3021                 :            :     case LABEL_REF:
    3022                 :            :       return 0;
    3023                 :            : 
    3024                 :      52052 :     case REG:
    3025                 :      77432 :       return reg_equiv[REGNO (x)].replace == 0 && rtx_varies_p (x, 0);
    3026                 :            : 
    3027                 :          0 :     case ASM_OPERANDS:
    3028                 :          0 :       if (MEM_VOLATILE_P (x))
    3029                 :            :         return 1;
    3030                 :            : 
    3031                 :            :       /* Fall through.  */
    3032                 :            : 
    3033                 :      50213 :     default:
    3034                 :      50213 :       break;
    3035                 :            :     }
    3036                 :            : 
    3037                 :      50213 :   fmt = GET_RTX_FORMAT (code);
    3038                 :     128496 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3039                 :      85902 :     if (fmt[i] == 'e')
    3040                 :            :       {
    3041                 :      85117 :         if (equiv_init_varies_p (XEXP (x, i)))
    3042                 :            :           return 1;
    3043                 :            :       }
    3044                 :        785 :     else if (fmt[i] == 'E')
    3045                 :            :       {
    3046                 :            :         int j;
    3047                 :       2411 :         for (j = 0; j < XVECLEN (x, i); j++)
    3048                 :       1888 :           if (equiv_init_varies_p (XVECEXP (x, i, j)))
    3049                 :            :             return 1;
    3050                 :            :       }
    3051                 :            : 
    3052                 :            :   return 0;
    3053                 :            : }
    3054                 :            : 
    3055                 :            : /* Returns nonzero if X (used to initialize register REGNO) is movable.
    3056                 :            :    X is only movable if the registers it uses have equivalent initializations
    3057                 :            :    which appear to be within the same loop (or in an inner loop) and movable
    3058                 :            :    or if they are not candidates for local_alloc and don't vary.  */
    3059                 :            : static int
    3060                 :    6413940 : equiv_init_movable_p (rtx x, int regno)
    3061                 :            : {
    3062                 :    8025990 :   int i, j;
    3063                 :    8025990 :   const char *fmt;
    3064                 :    8025990 :   enum rtx_code code = GET_CODE (x);
    3065                 :            : 
    3066                 :    8025990 :   switch (code)
    3067                 :            :     {
    3068                 :    1612050 :     case SET:
    3069                 :    1612050 :       return equiv_init_movable_p (SET_SRC (x), regno);
    3070                 :            : 
    3071                 :            :     case CC0:
    3072                 :            :     case CLOBBER:
    3073                 :            :       return 0;
    3074                 :            : 
    3075                 :            :     case PRE_INC:
    3076                 :            :     case PRE_DEC:
    3077                 :            :     case POST_INC:
    3078                 :            :     case POST_DEC:
    3079                 :            :     case PRE_MODIFY:
    3080                 :            :     case POST_MODIFY:
    3081                 :            :       return 0;
    3082                 :            : 
    3083                 :    1120980 :     case REG:
    3084                 :    1120980 :       return ((reg_equiv[REGNO (x)].loop_depth >= reg_equiv[regno].loop_depth
    3085                 :     840812 :                && reg_equiv[REGNO (x)].replace)
    3086                 :    1957280 :               || (REG_BASIC_BLOCK (REGNO (x)) < NUM_FIXED_BLOCKS
    3087                 :    1801330 :                   && ! rtx_varies_p (x, 0)));
    3088                 :            : 
    3089                 :            :     case UNSPEC_VOLATILE:
    3090                 :            :       return 0;
    3091                 :            : 
    3092                 :          0 :     case ASM_OPERANDS:
    3093                 :          0 :       if (MEM_VOLATILE_P (x))
    3094                 :            :         return 0;
    3095                 :            : 
    3096                 :            :       /* Fall through.  */
    3097                 :            : 
    3098                 :    4818180 :     default:
    3099                 :    4818180 :       break;
    3100                 :            :     }
    3101                 :            : 
    3102                 :    4818180 :   fmt = GET_RTX_FORMAT (code);
    3103                 :   11265000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3104                 :    7714540 :     switch (fmt[i])
    3105                 :            :       {
    3106                 :    3749420 :       case 'e':
    3107                 :    3749420 :         if (! equiv_init_movable_p (XEXP (x, i), regno))
    3108                 :            :           return 0;
    3109                 :            :         break;
    3110                 :     559621 :       case 'E':
    3111                 :     662531 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3112                 :     577689 :           if (! equiv_init_movable_p (XVECEXP (x, i, j), regno))
    3113                 :            :             return 0;
    3114                 :            :         break;
    3115                 :            :       }
    3116                 :            : 
    3117                 :            :   return 1;
    3118                 :            : }
    3119                 :            : 
    3120                 :            : static bool memref_referenced_p (rtx memref, rtx x, bool read_p);
    3121                 :            : 
    3122                 :            : /* Auxiliary function for memref_referenced_p.  Process setting X for
    3123                 :            :    MEMREF store.  */
    3124                 :            : static bool
    3125                 :     570053 : process_set_for_memref_referenced_p (rtx memref, rtx x)
    3126                 :            : {
    3127                 :            :   /* If we are setting a MEM, it doesn't count (its address does), but any
    3128                 :            :      other SET_DEST that has a MEM in it is referencing the MEM.  */
    3129                 :     570053 :   if (MEM_P (x))
    3130                 :            :     {
    3131                 :     453494 :       if (memref_referenced_p (memref, XEXP (x, 0), true))
    3132                 :      12562 :         return true;
    3133                 :            :     }
    3134                 :     116559 :   else if (memref_referenced_p (memref, x, false))
    3135                 :       1598 :     return true;
    3136                 :            :   
    3137                 :            :   return false;
    3138                 :            : }
    3139                 :            : 
    3140                 :            : /* TRUE if X references a memory location (as a read if READ_P) that
    3141                 :            :    would be affected by a store to MEMREF.  */
    3142                 :            : static bool
    3143                 :    2718750 : memref_referenced_p (rtx memref, rtx x, bool read_p)
    3144                 :            : {
    3145                 :    2718750 :   int i, j;
    3146                 :    2718750 :   const char *fmt;
    3147                 :    2718750 :   enum rtx_code code = GET_CODE (x);
    3148                 :            : 
    3149                 :    2718750 :   switch (code)
    3150                 :            :     {
    3151                 :            :     case CONST:
    3152                 :            :     case LABEL_REF:
    3153                 :            :     case SYMBOL_REF:
    3154                 :            :     CASE_CONST_ANY:
    3155                 :            :     case PC:
    3156                 :            :     case CC0:
    3157                 :            :     case HIGH:
    3158                 :            :     case LO_SUM:
    3159                 :            :       return false;
    3160                 :            : 
    3161                 :    1073290 :     case REG:
    3162                 :    1073290 :       return (reg_equiv[REGNO (x)].replacement
    3163                 :    1133900 :               && memref_referenced_p (memref,
    3164                 :      60617 :                                       reg_equiv[REGNO (x)].replacement, read_p));
    3165                 :            : 
    3166                 :      77925 :     case MEM:
    3167                 :            :       /* Memory X might have another effective type than MEMREF.  */
    3168                 :      77925 :       if (read_p || true_dependence (memref, VOIDmode, x))
    3169                 :      67066 :         return true;
    3170                 :            :       break;
    3171                 :            : 
    3172                 :     558433 :     case SET:
    3173                 :     558433 :       if (process_set_for_memref_referenced_p (memref, SET_DEST (x)))
    3174                 :            :         return true;
    3175                 :            : 
    3176                 :     544273 :       return memref_referenced_p (memref, SET_SRC (x), true);
    3177                 :            : 
    3178                 :      11620 :     case CLOBBER:
    3179                 :      11620 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3180                 :          0 :         return true;
    3181                 :            : 
    3182                 :            :       return false;
    3183                 :            : 
    3184                 :          0 :     case PRE_DEC:
    3185                 :          0 :     case POST_DEC:
    3186                 :          0 :     case PRE_INC:
    3187                 :          0 :     case POST_INC:
    3188                 :          0 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3189                 :            :         return true;
    3190                 :            : 
    3191                 :          0 :       return memref_referenced_p (memref, XEXP (x, 0), true);
    3192                 :            :       
    3193                 :          0 :     case POST_MODIFY:
    3194                 :          0 :     case PRE_MODIFY:
    3195                 :            :       /* op0 = op0 + op1 */
    3196                 :          0 :       if (process_set_for_memref_referenced_p (memref, XEXP (x, 0)))
    3197                 :            :         return true;
    3198                 :            : 
    3199                 :          0 :       if (memref_referenced_p (memref, XEXP (x, 0), true))
    3200                 :            :         return true;
    3201                 :            : 
    3202                 :          0 :       return memref_referenced_p (memref, XEXP (x, 1), true);
    3203                 :            : 
    3204                 :            :     default:
    3205                 :            :       break;
    3206                 :            :     }
    3207                 :            : 
    3208                 :     508491 :   fmt = GET_RTX_FORMAT (code);
    3209                 :    1472290 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3210                 :     987809 :     switch (fmt[i])
    3211                 :            :       {
    3212                 :     955475 :       case 'e':
    3213                 :     955475 :         if (memref_referenced_p (memref, XEXP (x, i), read_p))
    3214                 :            :           return true;
    3215                 :            :         break;
    3216                 :      14903 :       case 'E':
    3217                 :      43615 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3218                 :      30149 :           if (memref_referenced_p (memref, XVECEXP (x, i, j), read_p))
    3219                 :            :             return true;
    3220                 :            :         break;
    3221                 :            :       }
    3222                 :            : 
    3223                 :            :   return false;
    3224                 :            : }
    3225                 :            : 
    3226                 :            : /* TRUE if some insn in the range (START, END] references a memory location
    3227                 :            :    that would be affected by a store to MEMREF.
    3228                 :            : 
    3229                 :            :    Callers should not call this routine if START is after END in the
    3230                 :            :    RTL chain.  */
    3231                 :            : 
    3232                 :            : static int
    3233                 :     356397 : memref_used_between_p (rtx memref, rtx_insn *start, rtx_insn *end)
    3234                 :            : {
    3235                 :     356397 :   rtx_insn *insn;
    3236                 :            : 
    3237                 :     356397 :   for (insn = NEXT_INSN (start);
    3238                 :    1286730 :        insn && insn != NEXT_INSN (end);
    3239                 :     930330 :        insn = NEXT_INSN (insn))
    3240                 :            :     {
    3241                 :     997396 :       if (!NONDEBUG_INSN_P (insn))
    3242                 :     439214 :         continue;
    3243                 :            : 
    3244                 :     558182 :       if (memref_referenced_p (memref, PATTERN (insn), false))
    3245                 :            :         return 1;
    3246                 :            : 
    3247                 :            :       /* Nonconst functions may access memory.  */
    3248                 :     491116 :       if (CALL_P (insn) && (! RTL_CONST_CALL_P (insn)))
    3249                 :            :         return 1;
    3250                 :            :     }
    3251                 :            : 
    3252                 :     289331 :   gcc_assert (insn == NEXT_INSN (end));
    3253                 :            :   return 0;
    3254                 :            : }
    3255                 :            : 
    3256                 :            : /* Mark REG as having no known equivalence.
    3257                 :            :    Some instructions might have been processed before and furnished
    3258                 :            :    with REG_EQUIV notes for this register; these notes will have to be
    3259                 :            :    removed.
    3260                 :            :    STORE is the piece of RTL that does the non-constant / conflicting
    3261                 :            :    assignment - a SET, CLOBBER or REG_INC note.  It is currently not used,
    3262                 :            :    but needs to be there because this function is called from note_stores.  */
    3263                 :            : static void
    3264                 :   32931100 : no_equiv (rtx reg, const_rtx store ATTRIBUTE_UNUSED,
    3265                 :            :           void *data ATTRIBUTE_UNUSED)
    3266                 :            : {
    3267                 :   32931100 :   int regno;
    3268                 :   32931100 :   rtx_insn_list *list;
    3269                 :            : 
    3270                 :   32931100 :   if (!REG_P (reg))
    3271                 :            :     return;
    3272                 :   21778700 :   regno = REGNO (reg);
    3273                 :   21778700 :   reg_equiv[regno].no_equiv = 1;
    3274                 :   21778700 :   list = reg_equiv[regno].init_insns;
    3275                 :   21778700 :   if (list && list->insn () == NULL)
    3276                 :            :     return;
    3277                 :    4402120 :   reg_equiv[regno].init_insns = gen_rtx_INSN_LIST (VOIDmode, NULL_RTX, NULL);
    3278                 :    4402120 :   reg_equiv[regno].replacement = NULL_RTX;
    3279                 :            :   /* This doesn't matter for equivalences made for argument registers, we
    3280                 :            :      should keep their initialization insns.  */
    3281                 :    4402120 :   if (reg_equiv[regno].is_arg_equivalence)
    3282                 :            :     return;
    3283                 :    4399040 :   ira_reg_equiv[regno].defined_p = false;
    3284                 :    4399040 :   ira_reg_equiv[regno].init_insns = NULL;
    3285                 :    4920850 :   for (; list; list = list->next ())
    3286                 :            :     {
    3287                 :     500677 :       rtx_insn *insn = list->insn ();
    3288                 :     500677 :       remove_note (insn, find_reg_note (insn, REG_EQUIV, NULL_RTX));
    3289                 :            :     }
    3290                 :            : }
    3291                 :            : 
    3292                 :            : /* Check whether the SUBREG is a paradoxical subreg and set the result
    3293                 :            :    in PDX_SUBREGS.  */
    3294                 :            : 
    3295                 :            : static void
    3296                 :   52318400 : set_paradoxical_subreg (rtx_insn *insn)
    3297                 :            : {
    3298                 :   52318400 :   subrtx_iterator::array_type array;
    3299                 :  331428000 :   FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
    3300                 :            :     {
    3301                 :  279110000 :       const_rtx subreg = *iter;
    3302                 :  279110000 :       if (GET_CODE (subreg) == SUBREG)
    3303                 :            :         {
    3304                 :    1550500 :           const_rtx reg = SUBREG_REG (subreg);
    3305                 :    1550500 :           if (REG_P (reg) && paradoxical_subreg_p (subreg))
    3306                 :     219925 :             reg_equiv[REGNO (reg)].pdx_subregs = true;
    3307                 :            :         }
    3308                 :            :     }
    3309                 :   52318400 : }
    3310                 :            : 
    3311                 :            : /* In DEBUG_INSN location adjust REGs from CLEARED_REGS bitmap to the
    3312                 :            :    equivalent replacement.  */
    3313                 :            : 
    3314                 :            : static rtx
    3315                 :   19684000 : adjust_cleared_regs (rtx loc, const_rtx old_rtx ATTRIBUTE_UNUSED, void *data)
    3316                 :            : {
    3317                 :   19684000 :   if (REG_P (loc))
    3318                 :            :     {
    3319                 :    2843080 :       bitmap cleared_regs = (bitmap) data;
    3320                 :    2843080 :       if (bitmap_bit_p (cleared_regs, REGNO (loc)))
    3321                 :      66473 :         return simplify_replace_fn_rtx (copy_rtx (*reg_equiv[REGNO (loc)].src_p),
    3322                 :      66473 :                                         NULL_RTX, adjust_cleared_regs, data);
    3323                 :            :     }
    3324                 :            :   return NULL_RTX;
    3325                 :            : }
    3326                 :            : 
    3327                 :            : /* Given register REGNO is set only once, return true if the defining
    3328                 :            :    insn dominates all uses.  */
    3329                 :            : 
    3330                 :            : static bool
    3331                 :      44737 : def_dominates_uses (int regno)
    3332                 :            : {
    3333                 :      44737 :   df_ref def = DF_REG_DEF_CHAIN (regno);
    3334                 :            : 
    3335                 :      44737 :   struct df_insn_info *def_info = DF_REF_INSN_INFO (def);
    3336                 :            :   /* If this is an artificial def (eh handler regs, hard frame pointer
    3337                 :            :      for non-local goto, regs defined on function entry) then def_info
    3338                 :            :      is NULL and the reg is always live before any use.  We might
    3339                 :            :      reasonably return true in that case, but since the only call
    3340                 :            :      of this function is currently here in ira.c when we are looking
    3341                 :            :      at a defining insn we can't have an artificial def as that would
    3342                 :            :      bump DF_REG_DEF_COUNT.  */
    3343                 :      44737 :   gcc_assert (DF_REG_DEF_COUNT (regno) == 1 && def_info != NULL);
    3344                 :            : 
    3345                 :      44737 :   rtx_insn *def_insn = DF_REF_INSN (def);
    3346                 :      44737 :   basic_block def_bb = BLOCK_FOR_INSN (def_insn);
    3347                 :            : 
    3348                 :      44737 :   for (df_ref use = DF_REG_USE_CHAIN (regno);
    3349                 :     129593 :        use;
    3350                 :      84856 :        use = DF_REF_NEXT_REG (use))
    3351                 :            :     {
    3352                 :      84856 :       struct df_insn_info *use_info = DF_REF_INSN_INFO (use);
    3353                 :            :       /* Only check real uses, not artificial ones.  */
    3354                 :      84856 :       if (use_info)
    3355                 :            :         {
    3356                 :      84856 :           rtx_insn *use_insn = DF_REF_INSN (use);
    3357                 :      84856 :           if (!DEBUG_INSN_P (use_insn))
    3358                 :            :             {
    3359                 :      84613 :               basic_block use_bb = BLOCK_FOR_INSN (use_insn);
    3360                 :      84613 :               if (use_bb != def_bb
    3361                 :      84613 :                   ? !dominated_by_p (CDI_DOMINATORS, use_bb, def_bb)
    3362                 :      48907 :                   : DF_INSN_INFO_LUID (use_info) < DF_INSN_INFO_LUID (def_info))
    3363                 :            :                 return false;
    3364                 :            :             }
    3365                 :            :         }
    3366                 :            :     }
    3367                 :            :   return true;
    3368                 :            : }
    3369                 :            : 
    3370                 :            : /* Scan the instructions before update_equiv_regs.  Record which registers
    3371                 :            :    are referenced as paradoxical subregs.  Also check for cases in which
    3372                 :            :    the current function needs to save a register that one of its call
    3373                 :            :    instructions clobbers.
    3374                 :            : 
    3375                 :            :    These things are logically unrelated, but it's more efficient to do
    3376                 :            :    them together.  */
    3377                 :            : 
    3378                 :            : static void
    3379                 :     944096 : update_equiv_regs_prescan (void)
    3380                 :            : {
    3381                 :     944096 :   basic_block bb;
    3382                 :     944096 :   rtx_insn *insn;
    3383                 :     944096 :   function_abi_aggregator callee_abis;
    3384                 :            : 
    3385                 :   10020200 :   FOR_EACH_BB_FN (bb, cfun)
    3386                 :  203014000 :     FOR_BB_INSNS (bb, insn)
    3387                 :   96968800 :       if (NONDEBUG_INSN_P (insn))
    3388                 :            :         {
    3389                 :   52318400 :           set_paradoxical_subreg (insn);
    3390                 :   52318400 :           if (CALL_P (insn))
    3391                 :    3971300 :             callee_abis.note_callee_abi (insn_callee_abi (insn));
    3392                 :            :         }
    3393                 :            : 
    3394                 :     944096 :   HARD_REG_SET extra_caller_saves = callee_abis.caller_save_regs (*crtl->abi);
    3395                 :    1888190 :   if (!hard_reg_set_empty_p (extra_caller_saves))
    3396                 :          0 :     for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
    3397                 :          0 :       if (TEST_HARD_REG_BIT (extra_caller_saves, regno))
    3398                 :          0 :         df_set_regs_ever_live (regno, true);
    3399                 :     944096 : }
    3400                 :            : 
    3401                 :            : /* Find registers that are equivalent to a single value throughout the
    3402                 :            :    compilation (either because they can be referenced in memory or are
    3403                 :            :    set once from a single constant).  Lower their priority for a
    3404                 :            :    register.
    3405                 :            : 
    3406                 :            :    If such a register is only referenced once, try substituting its
    3407                 :            :    value into the using insn.  If it succeeds, we can eliminate the
    3408                 :            :    register completely.
    3409                 :            : 
    3410                 :            :    Initialize init_insns in ira_reg_equiv array.  */
    3411                 :            : static void
    3412                 :     944096 : update_equiv_regs (void)
    3413                 :            : {
    3414                 :     944096 :   rtx_insn *insn;
    3415                 :     944096 :   basic_block bb;
    3416                 :            : 
    3417                 :            :   /* Scan the insns and find which registers have equivalences.  Do this
    3418                 :            :      in a separate scan of the insns because (due to -fcse-follow-jumps)
    3419                 :            :      a register can be set below its use.  */
    3420                 :     944096 :   bitmap setjmp_crosses = regstat_get_setjmp_crosses ();
    3421                 :   10020200 :   FOR_EACH_BB_FN (bb, cfun)
    3422                 :            :     {
    3423                 :    9076070 :       int loop_depth = bb_loop_depth (bb);
    3424                 :            : 
    3425                 :    9076070 :       for (insn = BB_HEAD (bb);
    3426                 :  106045000 :            insn != NEXT_INSN (BB_END (bb));
    3427                 :   96968800 :            insn = NEXT_INSN (insn))
    3428                 :            :         {
    3429                 :   96968800 :           rtx note;
    3430                 :   96968800 :           rtx set;
    3431                 :   96968800 :           rtx dest, src;
    3432                 :   96968800 :           int regno;
    3433                 :            : 
    3434                 :   96968800 :           if (! INSN_P (insn))
    3435                 :   16611400 :             continue;
    3436                 :            : 
    3437                 :  132909000 :           for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    3438                 :   52551300 :             if (REG_NOTE_KIND (note) == REG_INC)
    3439                 :          0 :               no_equiv (XEXP (note, 0), note, NULL);
    3440                 :            : 
    3441                 :   80357500 :           set = single_set (insn);
    3442                 :            : 
    3443                 :            :           /* If this insn contains more (or less) than a single SET,
    3444                 :            :              only mark all destinations as having no known equivalence.  */
    3445                 :  114072000 :           if (set == NULL_RTX
    3446                 :   80357500 :               || side_effects_p (SET_SRC (set)))
    3447                 :            :             {
    3448                 :   33714500 :               note_pattern_stores (PATTERN (insn), no_equiv, NULL);
    3449                 :   33714500 :               continue;
    3450                 :            :             }
    3451                 :   46643000 :           else if (GET_CODE (PATTERN (insn)) == PARALLEL)
    3452                 :            :             {
    3453                 :    6472150 :               int i;
    3454                 :            : 
    3455                 :   19668200 :               for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
    3456                 :            :                 {
    3457                 :   13196100 :                   rtx part = XVECEXP (PATTERN (insn), 0, i);
    3458                 :   13196100 :                   if (part != set)
    3459                 :    6723930 :                     note_pattern_stores (part, no_equiv, NULL);
    3460                 :            :                 }
    3461                 :            :             }
    3462                 :            : 
    3463                 :   46643000 :           dest = SET_DEST (set);
    3464                 :   46643000 :           src = SET_SRC (set);
    3465                 :            : 
    3466                 :            :           /* See if this is setting up the equivalence between an argument
    3467                 :            :              register and its stack slot.  */
    3468                 :   46643000 :           note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
    3469                 :   46643000 :           if (note)
    3470                 :            :             {
    3471                 :     140636 :               gcc_assert (REG_P (dest));
    3472                 :     140636 :               regno = REGNO (dest);
    3473                 :            : 
    3474                 :            :               /* Note that we don't want to clear init_insns in
    3475                 :            :                  ira_reg_equiv even if there are multiple sets of this
    3476                 :            :                  register.  */
    3477                 :     140636 :               reg_equiv[regno].is_arg_equivalence = 1;
    3478                 :            : 
    3479                 :            :               /* The insn result can have equivalence memory although
    3480                 :            :                  the equivalence is not set up by the insn.  We add
    3481                 :            :                  this insn to init insns as it is a flag for now that
    3482                 :            :                  regno has an equivalence.  We will remove the insn
    3483                 :            :                  from init insn list later.  */
    3484                 :     140636 :               if (rtx_equal_p (src, XEXP (note, 0)) || MEM_P (XEXP (note, 0)))
    3485                 :     140636 :                 ira_reg_equiv[regno].init_insns
    3486                 :     140636 :                   = gen_rtx_INSN_LIST (VOIDmode, insn,
    3487                 :     140636 :                                        ira_reg_equiv[regno].init_insns);
    3488                 :            : 
    3489                 :            :               /* Continue normally in case this is a candidate for
    3490                 :            :                  replacements.  */
    3491                 :            :             }
    3492                 :            : 
    3493                 :   46643000 :           if (!optimize)
    3494                 :   12389300 :             continue;
    3495                 :            : 
    3496                 :            :           /* We only handle the case of a pseudo register being set
    3497                 :            :              once, or always to the same value.  */
    3498                 :            :           /* ??? The mn10200 port breaks if we add equivalences for
    3499                 :            :              values that need an ADDRESS_REGS register and set them equivalent
    3500                 :            :              to a MEM of a pseudo.  The actual problem is in the over-conservative
    3501                 :            :              handling of INPADDR_ADDRESS / INPUT_ADDRESS / INPUT triples in
    3502                 :            :              calculate_needs, but we traditionally work around this problem
    3503                 :            :              here by rejecting equivalences when the destination is in a register
    3504                 :            :              that's likely spilled.  This is fragile, of course, since the
    3505                 :            :              preferred class of a pseudo depends on all instructions that set
    3506                 :            :              or use it.  */
    3507                 :            : 
    3508                 :   56656600 :           if (!REG_P (dest)
    3509                 :   23080700 :               || (regno = REGNO (dest)) < FIRST_PSEUDO_REGISTER
    3510                 :   13202800 :               || (reg_equiv[regno].init_insns
    3511                 :    1811610 :                   && reg_equiv[regno].init_insns->insn () == NULL)
    3512                 :   46104500 :               || (targetm.class_likely_spilled_p (reg_preferred_class (regno))
    3513                 :        467 :                   && MEM_P (src) && ! reg_equiv[regno].is_arg_equivalence))
    3514                 :            :             {
    3515                 :            :               /* This might be setting a SUBREG of a pseudo, a pseudo that is
    3516                 :            :                  also set somewhere else to a constant.  */
    3517                 :   22402900 :               note_pattern_stores (set, no_equiv, NULL);
    3518                 :   22402900 :               continue;
    3519                 :            :             }
    3520                 :            : 
    3521                 :            :           /* Don't set reg mentioned in a paradoxical subreg
    3522                 :            :              equivalent to a mem.  */
    3523                 :   11850800 :           if (MEM_P (src) && reg_equiv[regno].pdx_subregs)
    3524                 :            :             {
    3525                 :       4870 :               note_pattern_stores (set, no_equiv, NULL);
    3526                 :       4870 :               continue;
    3527                 :            :             }
    3528                 :            : 
    3529                 :   11846000 :           note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
    3530                 :            : 
    3531                 :            :           /* cse sometimes generates function invariants, but doesn't put a
    3532                 :            :              REG_EQUAL note on the insn.  Since this note would be redundant,
    3533                 :            :              there's no point creating it earlier than here.  */
    3534                 :   11846000 :           if (! note && ! rtx_varies_p (src, 0))
    3535                 :    1682020 :             note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (src));
    3536                 :            : 
    3537                 :            :           /* Don't bother considering a REG_EQUAL note containing an EXPR_LIST
    3538                 :            :              since it represents a function call.  */
    3539                 :   11846000 :           if (note && GET_CODE (XEXP (note, 0)) == EXPR_LIST)
    3540                 :          0 :             note = NULL_RTX;
    3541                 :            : 
    3542                 :   11846000 :           if (DF_REG_DEF_COUNT (regno) != 1)
    3543                 :            :             {
    3544                 :    1663230 :               bool equal_p = true;
    3545                 :    1663230 :               rtx_insn_list *list;
    3546                 :            : 
    3547                 :            :               /* If we have already processed this pseudo and determined it
    3548                 :            :                  cannot have an equivalence, then honor that decision.  */
    3549                 :    1663230 :               if (reg_equiv[regno].no_equiv)
    3550                 :          0 :                 continue;
    3551                 :            : 
    3552                 :    2673110 :               if (! note
    3553                 :     670572 :                   || rtx_varies_p (XEXP (note, 0), 0)
    3554                 :    2316590 :                   || (reg_equiv[regno].replacement
    3555                 :          0 :                       && ! rtx_equal_p (XEXP (note, 0),
    3556                 :            :                                         reg_equiv[regno].replacement)))
    3557                 :            :                 {
    3558                 :    1009880 :                   no_equiv (dest, set, NULL);
    3559                 :    1009880 :                   continue;
    3560                 :            :                 }
    3561                 :            : 
    3562                 :     653354 :               list = reg_equiv[regno].init_insns;
    3563                 :    3185150 :               for (; list; list = list->next ())
    3564                 :            :                 {
    3565                 :    1357240 :                   rtx note_tmp;
    3566                 :    1357240 :                   rtx_insn *insn_tmp;
    3567                 :            : 
    3568                 :    1357240 :                   insn_tmp = list->insn ();
    3569                 :    1357240 :                   note_tmp = find_reg_note (insn_tmp, REG_EQUAL, NULL_RTX);
    3570                 :    1357240 :                   gcc_assert (note_tmp);
    3571                 :    1357240 :                   if (! rtx_equal_p (XEXP (note, 0), XEXP (note_tmp, 0)))
    3572                 :            :                     {
    3573                 :            :                       equal_p = false;
    3574                 :            :                       break;
    3575                 :            :                     }
    3576                 :            :                 }
    3577                 :            : 
    3578                 :     653354 :               if (! equal_p)
    3579                 :            :                 {
    3580                 :      38385 :                   no_equiv (dest, set, NULL);
    3581                 :      38385 :                   continue;
    3582                 :            :                 }
    3583                 :            :             }
    3584                 :            : 
    3585                 :            :           /* Record this insn as initializing this register.  */
    3586                 :   10797700 :           reg_equiv[regno].init_insns
    3587                 :   10797700 :             = gen_rtx_INSN_LIST (VOIDmode, insn, reg_equiv[regno].init_insns);
    3588                 :            : 
    3589                 :            :           /* If this register is known to be equal to a constant, record that
    3590                 :            :              it is always equivalent to the constant.
    3591                 :            :              Note that it is possible to have a register use before
    3592                 :            :              the def in loops (see gcc.c-torture/execute/pr79286.c)
    3593                 :            :              where the reg is undefined on first use.  If the def insn
    3594                 :            :              won't trap we can use it as an equivalence, effectively
    3595                 :            :              choosing the "undefined" value for the reg to be the
    3596                 :            :              same as the value set by the def.  */
    3597                 :   10797700 :           if (DF_REG_DEF_COUNT (regno) == 1
    3598                 :   10182700 :               && note
    3599                 :    1566010 :               && !rtx_varies_p (XEXP (note, 0), 0)
    3600                 :   12093300 :               && (!may_trap_or_fault_p (XEXP (note, 0))
    3601                 :      44737 :                   || def_dominates_uses (regno)))
    3602                 :            :             {
    3603                 :    1295580 :               rtx note_value = XEXP (note, 0);
    3604                 :    1295580 :               remove_note (insn, note);
    3605                 :    1295580 :               set_unique_reg_note (insn, REG_EQUIV, note_value);
    3606                 :            :             }
    3607                 :            : 
    3608                 :            :           /* If this insn introduces a "constant" register, decrease the priority
    3609                 :            :              of that register.  Record this insn if the register is only used once
    3610                 :            :              more and the equivalence value is the same as our source.
    3611                 :            : 
    3612                 :            :              The latter condition is checked for two reasons:  First, it is an
    3613                 :            :              indication that it may be more efficient to actually emit the insn
    3614                 :            :              as written (if no registers are available, reload will substitute
    3615                 :            :              the equivalence).  Secondly, it avoids problems with any registers
    3616                 :            :              dying in this insn whose death notes would be missed.
    3617                 :            : 
    3618                 :            :              If we don't have a REG_EQUIV note, see if this insn is loading
    3619                 :            :              a register used only in one basic block from a MEM.  If so, and the
    3620                 :            :              MEM remains unchanged for the life of the register, add a REG_EQUIV
    3621                 :            :              note.  */
    3622                 :   10797700 :           note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
    3623                 :            : 
    3624                 :   10797700 :           rtx replacement = NULL_RTX;
    3625                 :   10797700 :           if (note)
    3626                 :    1433130 :             replacement = XEXP (note, 0);
    3627                 :    9364570 :           else if (REG_BASIC_BLOCK (regno) >= NUM_FIXED_BLOCKS
    3628                 :    6777590 :                    && MEM_P (SET_SRC (set)))
    3629                 :            :             {
    3630                 :    1746640 :               enum valid_equiv validity;
    3631                 :    1746640 :               validity = validate_equiv_mem (insn, dest, SET_SRC (set));
    3632                 :    1746640 :               if (validity != valid_none)
    3633                 :            :                 {
    3634                 :    1328660 :                   replacement = copy_rtx (SET_SRC (set));
    3635                 :    1328660 :                   if (validity == valid_reload)
    3636                 :    1325780 :                     note = set_unique_reg_note (insn, REG_EQUIV, replacement);
    3637                 :            :                 }
    3638                 :            :             }
    3639                 :            : 
    3640                 :            :           /* If we haven't done so, record for reload that this is an
    3641                 :            :              equivalencing insn.  */
    3642                 :   10797700 :           if (note && !reg_equiv[regno].is_arg_equivalence)
    3643                 :    2621370 :             ira_reg_equiv[regno].init_insns
    3644                 :    2621370 :               = gen_rtx_INSN_LIST (VOIDmode, insn,
    3645                 :    2621370 :                                    ira_reg_equiv[regno].init_insns);
    3646                 :            : 
    3647                 :   10797700 :           if (replacement)
    3648                 :            :             {
    3649                 :    2761790 :               reg_equiv[regno].replacement = replacement;
    3650                 :    2761790 :               reg_equiv[regno].src_p = &SET_SRC (set);
    3651                 :    2761790 :               reg_equiv[regno].loop_depth = (short) loop_depth;
    3652                 :            : 
    3653                 :            :               /* Don't mess with things live during setjmp.  */
    3654                 :    2761790 :               if (optimize && !bitmap_bit_p (setjmp_crosses, regno))
    3655                 :            :                 {
    3656                 :            :                   /* If the register is referenced exactly twice, meaning it is
    3657                 :            :                      set once and used once, indicate that the reference may be
    3658                 :            :                      replaced by the equivalence we computed above.  Do this
    3659                 :            :                      even if the register is only used in one block so that
    3660                 :            :                      dependencies can be handled where the last register is
    3661                 :            :                      used in a different block (i.e. HIGH / LO_SUM sequences)
    3662                 :            :                      and to reduce the number of registers alive across
    3663                 :            :                      calls.  */
    3664                 :            : 
    3665                 :    2761750 :                   if (REG_N_REFS (regno) == 2
    3666                 :    2106930 :                       && (rtx_equal_p (replacement, src)
    3667                 :     161879 :                           || ! equiv_init_varies_p (src))
    3668                 :    2086830 :                       && NONJUMP_INSN_P (insn)
    3669                 :    4848580 :                       && equiv_init_movable_p (PATTERN (insn), regno))
    3670                 :    1175930 :                     reg_equiv[regno].replace = 1;
    3671                 :            :                 }
    3672                 :            :             }
    3673                 :            :         }
    3674                 :            :     }
    3675                 :     944096 : }
    3676                 :            : 
    3677                 :            : /* For insns that set a MEM to the contents of a REG that is only used
    3678                 :            :    in a single basic block, see if the register is always equivalent
    3679                 :            :    to that memory location and if moving the store from INSN to the
    3680                 :            :    insn that sets REG is safe.  If so, put a REG_EQUIV note on the
    3681                 :            :    initializing insn.  */
    3682                 :            : static void
    3683                 :     688548 : add_store_equivs (void)
    3684                 :            : {
    3685                 :     688548 :   auto_bitmap seen_insns;
    3686                 :            : 
    3687                 :  165501000 :   for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn))
    3688                 :            :     {
    3689                 :   82406400 :       rtx set, src, dest;
    3690                 :   82406400 :       unsigned regno;
    3691                 :   82406400 :       rtx_insn *init_insn;
    3692                 :            : 
    3693                 :   82406400 :       bitmap_set_bit (seen_insns, INSN_UID (insn));
    3694                 :            : 
    3695                 :   82406400 :       if (! INSN_P (insn))
    3696                 :   15839000 :         continue;
    3697                 :            : 
    3698                 :   66567400 :       set = single_set (insn);
    3699                 :   66567400 :       if (! set)
    3700                 :   30784800 :         continue;
    3701                 :            : 
    3702                 :   35782500 :       dest = SET_DEST (set);
    3703                 :   35782500 :       src = SET_SRC (set);
    3704                 :            : 
    3705                 :            :       /* Don't add a REG_EQUIV note if the insn already has one.  The existing
    3706                 :            :          REG_EQUIV is likely more useful than the one we are adding.  */
    3707                 :   39487400 :       if (MEM_P (dest) && REG_P (src)
    3708                 :    3704940 :           && (regno = REGNO (src)) >= FIRST_PSEUDO_REGISTER
    3709                 :    3653600 :           && REG_BASIC_BLOCK (regno) >= NUM_FIXED_BLOCKS
    3710                 :    1994470 :           && DF_REG_DEF_COUNT (regno) == 1
    3711                 :    1931770 :           && ! reg_equiv[regno].pdx_subregs
    3712                 :    1903710 :           && reg_equiv[regno].init_insns != NULL
    3713                 :    1903710 :           && (init_insn = reg_equiv[regno].init_insns->insn ()) != 0
    3714                 :    1889170 :           && bitmap_bit_p (seen_insns, INSN_UID (init_insn))
    3715                 :    1889170 :           && ! find_reg_note (init_insn, REG_EQUIV, NULL_RTX)
    3716                 :     665191 :           && validate_equiv_mem (init_insn, src, dest) == valid_reload
    3717                 :     356397 :           && ! memref_used_between_p (dest, init_insn, insn)
    3718                 :            :           /* Attaching a REG_EQUIV note will fail if INIT_INSN has
    3719                 :            :              multiple sets.  */
    3720                 :   36071800 :           && set_unique_reg_note (init_insn, REG_EQUIV, copy_rtx (dest)))
    3721                 :            :         {
    3722                 :            :           /* This insn makes the equivalence, not the one initializing
    3723                 :            :              the register.  */
    3724                 :     289178 :           ira_reg_equiv[regno].init_insns
    3725                 :     289178 :             = gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX);
    3726                 :     289178 :           df_notes_rescan (init_insn);
    3727                 :     289178 :           if (dump_file)
    3728                 :         92 :             fprintf (dump_file,
    3729                 :            :                      "Adding REG_EQUIV to insn %d for source of insn %d\n",
    3730                 :         92 :                      INSN_UID (init_insn),
    3731                 :         92 :                      INSN_UID (insn));
    3732                 :            :         }
    3733                 :            :     }
    3734                 :     688548 : }
    3735                 :            : 
    3736                 :            : /* Scan all regs killed in an insn to see if any of them are registers
    3737                 :            :    only used that once.  If so, see if we can replace the reference
    3738                 :            :    with the equivalent form.  If we can, delete the initializing
    3739                 :            :    reference and this register will go away.  If we can't replace the
    3740                 :            :    reference, and the initializing reference is within the same loop
    3741                 :            :    (or in an inner loop), then move the register initialization just
    3742                 :            :    before the use, so that they are in the same basic block.  */
    3743                 :            : static void
    3744                 :     688467 : combine_and_move_insns (void)
    3745                 :            : {
    3746                 :     688467 :   auto_bitmap cleared_regs;
    3747                 :     688467 :   int max = max_reg_num ();
    3748                 :            : 
    3749                 :   32863100 :   for (int regno = FIRST_PSEUDO_REGISTER; regno < max; regno++)
    3750                 :            :     {
    3751                 :   32174600 :       if (!reg_equiv[regno].replace)
    3752                 :   30999100 :         continue;
    3753                 :            : 
    3754                 :    1175500 :       rtx_insn *use_insn = 0;
    3755                 :    1175500 :       for (df_ref use = DF_REG_USE_CHAIN (regno);
    3756                 :    2419410 :            use;
    3757                 :    1243910 :            use = DF_REF_NEXT_REG (use))
    3758                 :    1243910 :         if (DF_REF_INSN_INFO (use))
    3759                 :            :           {
    3760                 :    1243910 :             if (DEBUG_INSN_P (DF_REF_INSN (use)))
    3761                 :      68417 :               continue;
    3762                 :    1175500 :             gcc_assert (!use_insn);
    3763                 :            :             use_insn = DF_REF_INSN (use);
    3764                 :            :           }
    3765                 :    1175500 :       gcc_assert (use_insn);
    3766                 :            : 
    3767                 :            :       /* Don't substitute into jumps.  indirect_jump_optimize does
    3768                 :            :          this for anything we are prepared to handle.  */
    3769                 :    1175500 :       if (JUMP_P (use_insn))
    3770                 :        381 :         continue;
    3771                 :            : 
    3772                 :            :       /* Also don't substitute into a conditional trap insn -- it can become
    3773                 :            :          an unconditional trap, and that is a flow control insn.  */
    3774                 :    1175120 :       if (GET_CODE (PATTERN (use_insn)) == TRAP_IF)
    3775                 :          0 :         continue;
    3776                 :            : 
    3777                 :    1175120 :       df_ref def = DF_REG_DEF_CHAIN (regno);
    3778                 :    1175120 :       gcc_assert (DF_REG_DEF_COUNT (regno) == 1 && DF_REF_INSN_INFO (def));
    3779                 :    1175120 :       rtx_insn *def_insn = DF_REF_INSN (def);
    3780                 :            : 
    3781                 :            :       /* We may not move instructions that can throw, since that
    3782                 :            :          changes basic block boundaries and we are not prepared to
    3783                 :            :          adjust the CFG to match.  */
    3784                 :    1175120 :       if (can_throw_internal (def_insn))
    3785                 :          0 :         continue;
    3786                 :            : 
    3787                 :            :       /* Instructions with multiple sets can only be moved if DF analysis is
    3788                 :            :          performed for all of the registers set.  See PR91052.  */
    3789                 :    1175120 :       if (multiple_sets (def_insn))
    3790                 :          0 :         continue;
    3791                 :            : 
    3792                 :    1175120 :       basic_block use_bb = BLOCK_FOR_INSN (use_insn);
    3793                 :    1175120 :       basic_block def_bb = BLOCK_FOR_INSN (def_insn);
    3794                 :    1175120 :       if (bb_loop_depth (use_bb) > bb_loop_depth (def_bb))
    3795                 :      93968 :         continue;
    3796                 :            : 
    3797                 :    1081150 :       if (asm_noperands (PATTERN (def_insn)) < 0
    3798                 :    2162300 :           && validate_replace_rtx (regno_reg_rtx[regno],
    3799                 :    1081150 :                                    *reg_equiv[regno].src_p, use_insn))
    3800                 :            :         {
    3801                 :     141804 :           rtx link;
    3802                 :            :           /* Append the REG_DEAD notes from def_insn.  */
    3803                 :     283748 :           for (rtx *p = &REG_NOTES (def_insn); (link = *p) != 0; )
    3804                 :            :             {
    3805                 :     141944 :               if (REG_NOTE_KIND (XEXP (link, 0)) == REG_DEAD)
    3806                 :            :                 {
    3807                 :          0 :                   *p = XEXP (link, 1);
    3808                 :          0 :                   XEXP (link, 1) = REG_NOTES (use_insn);
    3809                 :          0 :                   REG_NOTES (use_insn) = link;
    3810                 :            :                 }
    3811                 :            :               else
    3812                 :     141944 :                 p = &XEXP (link, 1);
    3813                 :            :             }
    3814                 :            : 
    3815                 :     141804 :           remove_death (regno, use_insn);
    3816                 :     141804 :           SET_REG_N_REFS (regno, 0);
    3817                 :     141804 :           REG_FREQ (regno) = 0;
    3818                 :     141804 :           df_ref use;
    3819                 :     205034 :           FOR_EACH_INSN_USE (use, def_insn)
    3820                 :            :             {
    3821                 :      63230 :               unsigned int use_regno = DF_REF_REGNO (use);
    3822                 :      63230 :               if (!HARD_REGISTER_NUM_P (use_regno))
    3823                 :        924 :                 reg_equiv[use_regno].replace = 0;
    3824                 :            :             }
    3825                 :            : 
    3826                 :     141804 :           delete_insn (def_insn);
    3827                 :            : 
    3828                 :     141804 :           reg_equiv[regno].init_insns = NULL;
    3829                 :     141804 :           ira_reg_equiv[regno].init_insns = NULL;
    3830                 :     141804 :           bitmap_set_bit (cleared_regs, regno);
    3831                 :            :         }
    3832                 :            : 
    3833                 :            :       /* Move the initialization of the register to just before
    3834                 :            :          USE_INSN.  Update the flow information.  */
    3835                 :     939344 :       else if (prev_nondebug_insn (use_insn) != def_insn)
    3836                 :            :         {
    3837                 :     211510 :           rtx_insn *new_insn;
    3838                 :            : 
    3839                 :     211510 :           new_insn = emit_insn_before (PATTERN (def_insn), use_insn);
    3840                 :     211510 :           REG_NOTES (new_insn) = REG_NOTES (def_insn);
    3841                 :     211510 :           REG_NOTES (def_insn) = 0;
    3842                 :            :           /* Rescan it to process the notes.  */
    3843                 :     211510 :           df_insn_rescan (new_insn);
    3844                 :            : 
    3845                 :            :           /* Make sure this insn is recognized before reload begins,
    3846                 :            :              otherwise eliminate_regs_in_insn will die.  */
    3847                 :     211510 :           INSN_CODE (new_insn) = INSN_CODE (def_insn);
    3848                 :            : 
    3849                 :     211510 :           delete_insn (def_insn);
    3850                 :            : 
    3851                 :     211510 :           XEXP (reg_equiv[regno].init_insns, 0) = new_insn;
    3852                 :            : 
    3853                 :     211510 :           REG_BASIC_BLOCK (regno) = use_bb->index;
    3854                 :     211510 :           REG_N_CALLS_CROSSED (regno) = 0;
    3855                 :            : 
    3856                 :     211510 :           if (use_insn == BB_HEAD (use_bb))
    3857                 :          0 :             BB_HEAD (use_bb) = new_insn;
    3858                 :            : 
    3859                 :            :           /* We know regno dies in use_insn, but inside a loop
    3860                 :            :              REG_DEAD notes might be missing when def_insn was in
    3861                 :            :              another basic block.  However, when we move def_insn into
    3862                 :            :              this bb we'll definitely get a REG_DEAD note and reload
    3863                 :            :              will see the death.  It's possible that update_equiv_regs
    3864                 :            :              set up an equivalence referencing regno for a reg set by
    3865                 :            :              use_insn, when regno was seen as non-local.  Now that
    3866                 :            :              regno is local to this block, and dies, such an
    3867                 :            :              equivalence is invalid.  */
    3868                 :     211510 :           if (find_reg_note (use_insn, REG_EQUIV, regno_reg_rtx[regno]))
    3869                 :            :             {
    3870                 :          0 :               rtx set = single_set (use_insn);
    3871                 :          0 :               if (set && REG_P (SET_DEST (set)))
    3872                 :          0 :                 no_equiv (SET_DEST (set), set, NULL);
    3873                 :            :             }
    3874                 :            : 
    3875                 :     211510 :           ira_reg_equiv[regno].init_insns
    3876                 :     211510 :             = gen_rtx_INSN_LIST (VOIDmode, new_insn, NULL_RTX);
    3877                 :     211510 :           bitmap_set_bit (cleared_regs, regno);
    3878                 :            :         }
    3879                 :            :     }
    3880                 :            : 
    3881                 :     688467 :   if (!bitmap_empty_p (cleared_regs))
    3882                 :            :     {
    3883                 :     116008 :       basic_block bb;
    3884                 :            : 
    3885                 :    3200200 :       FOR_EACH_BB_FN (bb, cfun)
    3886                 :            :         {
    3887                 :    6168390 :           bitmap_and_compl_into (DF_LR_IN (bb), cleared_regs);
    3888                 :    6168390 :           bitmap_and_compl_into (DF_LR_OUT (bb), cleared_regs);
    3889                 :    3084190 :           if (!df_live)
    3890                 :    3084190 :             continue;
    3891                 :          0 :           bitmap_and_compl_into (DF_LIVE_IN (bb), cleared_regs);
    3892                 :          0 :           bitmap_and_compl_into (DF_LIVE_OUT (bb), cleared_regs);
    3893                 :            :         }
    3894                 :            : 
    3895                 :            :       /* Last pass - adjust debug insns referencing cleared regs.  */
    3896                 :     116008 :       if (MAY_HAVE_DEBUG_BIND_INSNS)
    3897                 :   64287400 :         for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn))
    3898                 :   32104700 :           if (DEBUG_BIND_INSN_P (insn))
    3899                 :            :             {
    3900                 :   10743100 :               rtx old_loc = INSN_VAR_LOCATION_LOC (insn);
    3901                 :   10743100 :               INSN_VAR_LOCATION_LOC (insn)
    3902                 :   21486100 :                 = simplify_replace_fn_rtx (old_loc, NULL_RTX,
    3903                 :            :                                            adjust_cleared_regs,
    3904                 :   10743100 :                                            (void *) cleared_regs);
    3905                 :   10743100 :               if (old_loc != INSN_VAR_LOCATION_LOC (insn))
    3906                 :      64598 :                 df_insn_rescan (insn);
    3907                 :            :             }
    3908                 :            :     }
    3909                 :     688467 : }
    3910                 :            : 
    3911                 :            : /* A pass over indirect jumps, converting simple cases to direct jumps.
    3912                 :            :    Combine does this optimization too, but only within a basic block.  */
    3913                 :            : static void
    3914                 :     944096 : indirect_jump_optimize (void)
    3915                 :            : {
    3916                 :     944096 :   basic_block bb;
    3917                 :     944096 :   bool rebuild_p = false;
    3918                 :            : 
    3919                 :   10020200 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    3920                 :            :     {
    3921                 :    9076080 :       rtx_insn *insn = BB_END (bb);
    3922                 :   12742000 :       if (!JUMP_P (insn)
    3923                 :    9076080 :           || find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
    3924                 :    3665940 :         continue;
    3925                 :            : 
    3926                 :    5410140 :       rtx x = pc_set (insn);
    3927                 :    5410140 :       if (!x || !REG_P (SET_SRC (x)))
    3928                 :    5402140 :         continue;
    3929                 :            : 
    3930                 :       7997 :       int regno = REGNO (SET_SRC (x));
    3931                 :       7997 :       if (DF_REG_DEF_COUNT (regno) == 1)
    3932                 :            :         {
    3933                 :       7880 :           df_ref def = DF_REG_DEF_CHAIN (regno);
    3934                 :       7880 :           if (!DF_REF_IS_ARTIFICIAL (def))
    3935                 :            :             {
    3936                 :       7880 :               rtx_insn *def_insn = DF_REF_INSN (def);
    3937                 :       7880 :               rtx lab = NULL_RTX;
    3938                 :       7880 :               rtx set = single_set (def_insn);
    3939                 :       7880 :               if (set && GET_CODE (SET_SRC (set)) == LABEL_REF)
    3940                 :            :                 lab = SET_SRC (set);
    3941                 :            :               else
    3942                 :            :                 {
    3943                 :       7879 :                   rtx eqnote = find_reg_note (def_insn, REG_EQUAL, NULL_RTX);
    3944                 :       7879 :                   if (eqnote && GET_CODE (XEXP (eqnote, 0)) == LABEL_REF)
    3945                 :            :                     lab = XEXP (eqnote, 0);
    3946                 :            :                 }
    3947                 :          1 :               if (lab && validate_replace_rtx (SET_SRC (x), lab, insn))
    3948                 :            :                 rebuild_p = true;
    3949                 :            :             }
    3950                 :            :         }
    3951                 :            :     }
    3952                 :            : 
    3953                 :     944096 :   if (rebuild_p)
    3954                 :            :     {
    3955                 :          1 :       timevar_push (TV_JUMP);
    3956                 :          1 :       rebuild_jump_labels (get_insns ());
    3957                 :          1 :       if (purge_all_dead_edges ())
    3958                 :          1 :         delete_unreachable_blocks ();
    3959                 :          1 :       timevar_pop (TV_JUMP);
    3960                 :            :     }
    3961                 :     944096 : }
    3962                 :            : 
    3963                 :            : /* Set up fields memory, constant, and invariant from init_insns in
    3964                 :            :    the structures of array ira_reg_equiv.  */
    3965                 :            : static void
    3966                 :     944096 : setup_reg_equiv (void)
    3967                 :            : {
    3968                 :     944096 :   int i;
    3969                 :     944096 :   rtx_insn_list *elem, *prev_elem, *next_elem;
    3970                 :     944096 :   rtx_insn *insn;
    3971                 :     944096 :   rtx set, x;
    3972                 :            : 
    3973                 :   97741600 :   for (i = FIRST_PSEUDO_REGISTER; i < ira_reg_equiv_len; i++)
    3974                 :   96797500 :     for (prev_elem = NULL, elem = ira_reg_equiv[i].init_insns;
    3975                 :   99553800 :          elem;
    3976                 :            :          prev_elem = elem, elem = next_elem)
    3977                 :            :       {
    3978                 :    2909470 :         next_elem = elem->next ();
    3979                 :    2909470 :         insn = elem->insn ();
    3980                 :    2909470 :         set = single_set (insn);
    3981                 :            :         
    3982                 :            :         /* Init insns can set up equivalence when the reg is a destination or
    3983                 :            :            a source (in this case the destination is memory).  */
    3984                 :    2909470 :         if (set != 0 && (REG_P (SET_DEST (set)) || REG_P (SET_SRC (set))))
    3985                 :            :           {
    3986                 :    2909470 :             if ((x = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != NULL)
    3987                 :            :               {
    3988                 :    2620270 :                 x = XEXP (x, 0);
    3989                 :    2620270 :                 if (REG_P (SET_DEST (set))
    3990                 :    2620270 :                     && REGNO (SET_DEST (set)) == (unsigned int) i
    3991                 :    5240530 :                     && ! rtx_equal_p (SET_SRC (set), x) && MEM_P (x))
    3992                 :            :                   {
    3993                 :            :                     /* This insn reporting the equivalence but
    3994                 :            :                        actually not setting it.  Remove it from the
    3995                 :            :                        list.  */
    3996                 :      13433 :                     if (prev_elem == NULL)
    3997                 :      13433 :                       ira_reg_equiv[i].init_insns = next_elem;
    3998                 :            :                     else
    3999                 :          0 :                       XEXP (prev_elem, 1) = next_elem;
    4000                 :            :                     elem = prev_elem;
    4001                 :            :                   }
    4002                 :            :               }
    4003                 :     289207 :             else if (REG_P (SET_DEST (set))
    4004                 :     289207 :                      && REGNO (SET_DEST (set)) == (unsigned int) i)
    4005                 :         29 :               x = SET_SRC (set);
    4006                 :            :             else
    4007                 :            :               {      
    4008                 :     289178 :                 gcc_assert (REG_P (SET_SRC (set))
    4009                 :            :                             && REGNO (SET_SRC (set)) == (unsigned int) i);
    4010                 :            :                 x = SET_DEST (set);
    4011                 :            :               }
    4012                 :    2909470 :             if (! function_invariant_p (x)
    4013                 :    1106680 :                 || ! flag_pic
    4014                 :            :                 /* A function invariant is often CONSTANT_P but may
    4015                 :            :                    include a register.  We promise to only pass
    4016                 :            :                    CONSTANT_P objects to LEGITIMATE_PIC_OPERAND_P.  */
    4017                 :    3063010 :                 || (CONSTANT_P (x) && LEGITIMATE_PIC_OPERAND_P (x)))
    4018                 :            :               {
    4019                 :            :                 /* It can happen that a REG_EQUIV note contains a MEM
    4020                 :            :                    that is not a legitimate memory operand.  As later
    4021                 :            :                    stages of reload assume that all addresses found in
    4022                 :            :                    the lra_regno_equiv_* arrays were originally
    4023                 :            :                    legitimate, we ignore such REG_EQUIV notes.  */
    4024                 :    2793450 :                 if (memory_operand (x, VOIDmode))
    4025                 :            :                   {
    4026                 :    1766160 :                     ira_reg_equiv[i].defined_p = true;
    4027                 :    1766160 :                     ira_reg_equiv[i].memory = x;
    4028                 :    1766160 :                     continue;
    4029                 :            :                   }
    4030                 :    1027290 :                 else if (function_invariant_p (x))
    4031                 :            :                   {
    4032                 :     990659 :                     machine_mode mode;
    4033                 :            :                     
    4034                 :     990659 :                     mode = GET_MODE (SET_DEST (set));
    4035                 :     990659 :                     if (GET_CODE (x) == PLUS
    4036                 :     410892 :                         || x == frame_pointer_rtx || x == arg_pointer_rtx)
    4037                 :            :                       /* This is PLUS of frame pointer and a constant,
    4038                 :            :                          or fp, or argp.  */
    4039                 :     581839 :                       ira_reg_equiv[i].invariant = x;
    4040                 :     408820 :                     else if (targetm.legitimate_constant_p (mode, x))
    4041                 :     354277 :                       ira_reg_equiv[i].constant = x;
    4042                 :            :                     else
    4043                 :            :                       {
    4044                 :      54543 :                         ira_reg_equiv[i].memory = force_const_mem (mode, x);
    4045                 :      54543 :                         if (ira_reg_equiv[i].memory == NULL_RTX)
    4046                 :            :                           {
    4047                 :        537 :                             ira_reg_equiv[i].defined_p = false;
    4048                 :        537 :                             ira_reg_equiv[i].init_insns = NULL;
    4049                 :        537 :                             break;
    4050                 :            :                           }
    4051                 :            :                       }
    4052                 :     990122 :                     ira_reg_equiv[i].defined_p = true;
    4053                 :     990122 :                     continue;
    4054                 :            :                   }
    4055                 :            :               }
    4056                 :            :           }
    4057                 :     152655 :         ira_reg_equiv[i].defined_p = false;
    4058                 :     152655 :         ira_reg_equiv[i].init_insns = NULL;
    4059                 :     152655 :         break;
    4060                 :            :       }
    4061                 :     944096 : }
    4062                 :            : 
    4063                 :            : 
    4064                 :            : 
    4065                 :            : /* Print chain C to FILE.  */
    4066                 :            : static void
    4067                 :          0 : print_insn_chain (FILE *file, class insn_chain *c)
    4068                 :            : {
    4069                 :          0 :   fprintf (file, "insn=%d, ", INSN_UID (c->insn));
    4070                 :          0 :   bitmap_print (file, &c->live_throughout, "live_throughout: ", ", ");
    4071                 :          0 :   bitmap_print (file, &c->dead_or_set, "dead_or_set: ", "\n");
    4072                 :          0 : }
    4073                 :            : 
    4074                 :            : 
    4075                 :            : /* Print all reload_insn_chains to FILE.  */
    4076                 :            : static void
    4077                 :          0 : print_insn_chains (FILE *file)
    4078                 :            : {
    4079                 :          0 :   class insn_chain *c;
    4080                 :          0 :   for (c = reload_insn_chain; c ; c = c->next)
    4081                 :          0 :     print_insn_chain (file, c);
    4082                 :          0 : }
    4083                 :            : 
    4084                 :            : /* Return true if pseudo REGNO should be added to set live_throughout
    4085                 :            :    or dead_or_set of the insn chains for reload consideration.  */
    4086                 :            : static bool
    4087                 :          0 : pseudo_for_reload_consideration_p (int regno)
    4088                 :            : {
    4089                 :            :   /* Consider spilled pseudos too for IRA because they still have a
    4090                 :            :      chance to get hard-registers in the reload when IRA is used.  */
    4091                 :          0 :   return (reg_renumber[regno] >= 0 || ira_conflicts_p);
    4092                 :            : }
    4093                 :            : 
    4094                 :            : /* Return true if we can track the individual bytes of subreg X.
    4095                 :            :    When returning true, set *OUTER_SIZE to the number of bytes in
    4096                 :            :    X itself, *INNER_SIZE to the number of bytes in the inner register
    4097                 :            :    and *START to the offset of the first byte.  */
    4098                 :            : static bool
    4099                 :          0 : get_subreg_tracking_sizes (rtx x, HOST_WIDE_INT *outer_size,
    4100                 :            :                            HOST_WIDE_INT *inner_size, HOST_WIDE_INT *start)
    4101                 :            : {
    4102                 :          0 :   rtx reg = regno_reg_rtx[REGNO (SUBREG_REG (x))];
    4103                 :          0 :   return (GET_MODE_SIZE (GET_MODE (x)).is_constant (outer_size)
    4104                 :          0 :           && GET_MODE_SIZE (GET_MODE (reg)).is_constant (inner_size)
    4105                 :          0 :           && SUBREG_BYTE (x).is_constant (start));
    4106                 :            : }
    4107                 :            : 
    4108                 :            : /* Init LIVE_SUBREGS[ALLOCNUM] and LIVE_SUBREGS_USED[ALLOCNUM] for
    4109                 :            :    a register with SIZE bytes, making the register live if INIT_VALUE.  */
    4110                 :            : static void
    4111                 :          0 : init_live_subregs (bool init_value, sbitmap *live_subregs,
    4112                 :            :                    bitmap live_subregs_used, int allocnum, int size)
    4113                 :            : {
    4114                 :          0 :   gcc_assert (size > 0);
    4115                 :            : 
    4116                 :            :   /* Been there, done that.  */
    4117                 :          0 :   if (bitmap_bit_p (live_subregs_used, allocnum))
    4118                 :            :     return;
    4119                 :            : 
    4120                 :            :   /* Create a new one.  */
    4121                 :          0 :   if (live_subregs[allocnum] == NULL)
    4122                 :          0 :     live_subregs[allocnum] = sbitmap_alloc (size);
    4123                 :            : 
    4124                 :            :   /* If the entire reg was live before blasting into subregs, we need
    4125                 :            :      to init all of the subregs to ones else init to 0.  */
    4126                 :          0 :   if (init_value)
    4127                 :          0 :     bitmap_ones (live_subregs[allocnum]);
    4128                 :            :   else
    4129                 :          0 :     bitmap_clear (live_subregs[allocnum]);
    4130                 :            : 
    4131                 :          0 :   bitmap_set_bit (live_subregs_used, allocnum);
    4132                 :            : }
    4133                 :            : 
    4134                 :            : /* Walk the insns of the current function and build reload_insn_chain,
    4135                 :            :    and record register life information.  */
    4136                 :            : static void
    4137                 :          0 : build_insn_chain (void)
    4138                 :            : {
    4139                 :          0 :   unsigned int i;
    4140                 :          0 :   class insn_chain **p = &reload_insn_chain;
    4141                 :          0 :   basic_block bb;
    4142                 :          0 :   class insn_chain *c = NULL;
    4143                 :          0 :   class insn_chain *next = NULL;
    4144                 :          0 :   auto_bitmap live_relevant_regs;
    4145                 :          0 :   auto_bitmap elim_regset;
    4146                 :            :   /* live_subregs is a vector used to keep accurate information about
    4147                 :            :      which hardregs are live in multiword pseudos.  live_subregs and
    4148                 :            :      live_subregs_used are indexed by pseudo number.  The live_subreg
    4149                 :            :      entry for a particular pseudo is only used if the corresponding
    4150                 :            :      element is non zero in live_subregs_used.  The sbitmap size of
    4151                 :            :      live_subreg[allocno] is number of bytes that the pseudo can
    4152                 :            :      occupy.  */
    4153                 :          0 :   sbitmap *live_subregs = XCNEWVEC (sbitmap, max_regno);
    4154                 :          0 :   auto_bitmap live_subregs_used;
    4155                 :            : 
    4156                 :          0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    4157                 :          0 :     if (TEST_HARD_REG_BIT (eliminable_regset, i))
    4158                 :          0 :       bitmap_set_bit (elim_regset, i);
    4159                 :          0 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    4160                 :            :     {
    4161                 :          0 :       bitmap_iterator bi;
    4162                 :          0 :       rtx_insn *insn;
    4163                 :            : 
    4164                 :          0 :       CLEAR_REG_SET (live_relevant_regs);
    4165                 :          0 :       bitmap_clear (live_subregs_used);
    4166                 :            : 
    4167                 :          0 :       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb), 0, i, bi)
    4168                 :            :         {
    4169                 :          0 :           if (i >= FIRST_PSEUDO_REGISTER)
    4170                 :            :             break;
    4171                 :          0 :           bitmap_set_bit (live_relevant_regs, i);
    4172                 :            :         }
    4173                 :            : 
    4174                 :          0 :       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb),
    4175                 :            :                                 FIRST_PSEUDO_REGISTER, i, bi)
    4176                 :            :         {
    4177                 :          0 :           if (pseudo_for_reload_consideration_p (i))
    4178                 :          0 :             bitmap_set_bit (live_relevant_regs, i);
    4179                 :            :         }
    4180                 :            : 
    4181                 :          0 :       FOR_BB_INSNS_REVERSE (bb, insn)
    4182                 :            :         {
    4183                 :          0 :           if (!NOTE_P (insn) && !BARRIER_P (insn))
    4184                 :            :             {
    4185                 :          0 :               struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4186                 :          0 :               df_ref def, use;
    4187                 :            : 
    4188                 :          0 :               c = new_insn_chain ();
    4189                 :          0 :               c->next = next;
    4190                 :          0 :               next = c;
    4191                 :          0 :               *p = c;
    4192                 :          0 :               p = &c->prev;
    4193                 :            : 
    4194                 :          0 :               c->insn = insn;
    4195                 :          0 :               c->block = bb->index;
    4196                 :            : 
    4197                 :          0 :               if (NONDEBUG_INSN_P (insn))
    4198                 :          0 :                 FOR_EACH_INSN_INFO_DEF (def, insn_info)
    4199                 :            :                   {
    4200                 :          0 :                     unsigned int regno = DF_REF_REGNO (def);
    4201                 :            : 
    4202                 :            :                     /* Ignore may clobbers because these are generated
    4203                 :            :                        from calls. However, every other kind of def is
    4204                 :            :                        added to dead_or_set.  */
    4205                 :          0 :                     if (!DF_REF_FLAGS_IS_SET (def, DF_REF_MAY_CLOBBER))
    4206                 :            :                       {
    4207                 :          0 :                         if (regno < FIRST_PSEUDO_REGISTER)
    4208                 :            :                           {
    4209                 :          0 :                             if (!fixed_regs[regno])
    4210                 :          0 :                               bitmap_set_bit (&c->dead_or_set, regno);
    4211                 :            :                           }
    4212                 :          0 :                         else if (pseudo_for_reload_consideration_p (regno))
    4213                 :          0 :                           bitmap_set_bit (&c->dead_or_set, regno);
    4214                 :            :                       }
    4215                 :            : 
    4216                 :          0 :                     if ((regno < FIRST_PSEUDO_REGISTER
    4217                 :          0 :                          || reg_renumber[regno] >= 0
    4218                 :          0 :                          || ira_conflicts_p)
    4219                 :          0 :                         && (!DF_REF_FLAGS_IS_SET (def, DF_REF_CONDITIONAL)))
    4220                 :            :                       {
    4221                 :          0 :                         rtx reg = DF_REF_REG (def);
    4222                 :          0 :                         HOST_WIDE_INT outer_size, inner_size, start;
    4223                 :            : 
    4224                 :            :                         /* We can usually track the liveness of individual
    4225                 :            :                            bytes within a subreg.  The only exceptions are
    4226                 :            :                            subregs wrapped in ZERO_EXTRACTs and subregs whose
    4227                 :            :                            size is not known; in those cases we need to be
    4228                 :            :                            conservative and treat the definition as a partial
    4229                 :            :                            definition of the full register rather than a full
    4230                 :            :                            definition of a specific part of the register.  */
    4231                 :          0 :                         if (GET_CODE (reg) == SUBREG
    4232                 :          0 :                             && !DF_REF_FLAGS_IS_SET (def, DF_REF_ZERO_EXTRACT)
    4233                 :          0 :                             && get_subreg_tracking_sizes (reg, &outer_size,
    4234                 :            :                                                           &inner_size, &start))
    4235                 :            :                           {
    4236                 :          0 :                             HOST_WIDE_INT last = start + outer_size;
    4237                 :            : 
    4238                 :          0 :                             init_live_subregs
    4239                 :          0 :                               (bitmap_bit_p (live_relevant_regs, regno),
    4240                 :            :                                live_subregs, live_subregs_used, regno,
    4241                 :            :                                inner_size);
    4242                 :            : 
    4243                 :          0 :                             if (!DF_REF_FLAGS_IS_SET
    4244                 :            :                                 (def, DF_REF_STRICT_LOW_PART))
    4245                 :            :                               {
    4246                 :            :                                 /* Expand the range to cover entire words.
    4247                 :            :                                    Bytes added here are "don't care".  */
    4248                 :          0 :                                 start
    4249                 :          0 :                                   = start / UNITS_PER_WORD * UNITS_PER_WORD;
    4250                 :          0 :                                 last = ((last + UNITS_PER_WORD - 1)
    4251                 :          0 :                                         / UNITS_PER_WORD * UNITS_PER_WORD);
    4252                 :            :                               }
    4253                 :            : 
    4254                 :            :                             /* Ignore the paradoxical bits.  */
    4255                 :          0 :                             if (last > SBITMAP_SIZE (live_subregs[regno]))
    4256                 :            :                               last = SBITMAP_SIZE (live_subregs[regno]);
    4257                 :            : 
    4258                 :          0 :                             while (start < last)
    4259                 :            :                               {
    4260                 :          0 :                                 bitmap_clear_bit (live_subregs[regno], start);
    4261                 :          0 :                                 start++;
    4262                 :            :                               }
    4263                 :            : 
    4264                 :          0 :                             if (bitmap_empty_p (live_subregs[regno]))
    4265                 :            :                               {
    4266                 :          0 :                                 bitmap_clear_bit (live_subregs_used, regno);
    4267                 :          0 :                                 bitmap_clear_bit (live_relevant_regs, regno);
    4268                 :            :                               }
    4269                 :            :                             else
    4270                 :            :                               /* Set live_relevant_regs here because
    4271                 :            :                                  that bit has to be true to get us to
    4272                 :            :                                  look at the live_subregs fields.  */
    4273                 :          0 :                               bitmap_set_bit (live_relevant_regs, regno);
    4274                 :            :                           }
    4275                 :            :                         else
    4276                 :            :                           {
    4277                 :            :                             /* DF_REF_PARTIAL is generated for
    4278                 :            :                                subregs, STRICT_LOW_PART, and
    4279                 :            :                                ZERO_EXTRACT.  We handle the subreg
    4280                 :            :                                case above so here we have to keep from
    4281                 :            :                                modeling the def as a killing def.  */
    4282                 :          0 :                             if (!DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL))
    4283                 :            :                               {
    4284                 :          0 :                                 bitmap_clear_bit (live_subregs_used, regno);
    4285                 :          0 :                                 bitmap_clear_bit (live_relevant_regs, regno);
    4286                 :            :                               }
    4287                 :            :                           }
    4288                 :            :                       }
    4289                 :            :                   }
    4290                 :            : 
    4291                 :          0 :               bitmap_and_compl_into (live_relevant_regs, elim_regset);
    4292                 :          0 :               bitmap_copy (&c->live_throughout, live_relevant_regs);
    4293                 :            : 
    4294                 :          0 :               if (NONDEBUG_INSN_P (insn))
    4295                 :          0 :                 FOR_EACH_INSN_INFO_USE (use, insn_info)
    4296                 :            :                   {
    4297                 :          0 :                     unsigned int regno = DF_REF_REGNO (use);
    4298                 :          0 :                     rtx reg = DF_REF_REG (use);
    4299                 :            : 
    4300                 :            :                     /* DF_REF_READ_WRITE on a use means that this use
    4301                 :            :                        is fabricated from a def that is a partial set
    4302                 :            :                        to a multiword reg.  Here, we only model the
    4303                 :            :                        subreg case that is not wrapped in ZERO_EXTRACT
    4304                 :            :                        precisely so we do not need to look at the
    4305                 :            :                        fabricated use.  */
    4306                 :          0 :                     if (DF_REF_FLAGS_IS_SET (use, DF_REF_READ_WRITE)
    4307                 :            :                         && !DF_REF_FLAGS_IS_SET (use, DF_REF_ZERO_EXTRACT)
    4308                 :          0 :                         && DF_REF_FLAGS_IS_SET (use, DF_REF_SUBREG))
    4309                 :          0 :                       continue;
    4310                 :            : 
    4311                 :            :                     /* Add the last use of each var to dead_or_set.  */
    4312                 :          0 :                     if (!bitmap_bit_p (live_relevant_regs, regno))
    4313                 :            :                       {
    4314                 :          0 :                         if (regno < FIRST_PSEUDO_REGISTER)
    4315                 :            :                           {
    4316                 :          0 :                             if (!fixed_regs[regno])
    4317                 :          0 :                               bitmap_set_bit (&c->dead_or_set, regno);
    4318                 :            :                           }
    4319                 :          0 :                         else if (pseudo_for_reload_consideration_p (regno))
    4320                 :          0 :                           bitmap_set_bit (&c->dead_or_set, regno);
    4321                 :            :                       }
    4322                 :            : 
    4323                 :          0 :                     if (regno < FIRST_PSEUDO_REGISTER
    4324                 :          0 :                         || pseudo_for_reload_consideration_p (regno))
    4325                 :            :                       {
    4326                 :          0 :                         HOST_WIDE_INT outer_size, inner_size, start;
    4327                 :          0 :                         if (GET_CODE (reg) == SUBREG
    4328                 :          0 :                             && !DF_REF_FLAGS_IS_SET (use,
    4329                 :            :                                                      DF_REF_SIGN_EXTRACT
    4330                 :            :                                                      | DF_REF_ZERO_EXTRACT)
    4331                 :          0 :                             && get_subreg_tracking_sizes (reg, &outer_size,
    4332                 :            :                                                           &inner_size, &start))
    4333                 :            :                           {
    4334                 :          0 :                             HOST_WIDE_INT last = start + outer_size;
    4335                 :            : 
    4336                 :          0 :                             init_live_subregs
    4337                 :          0 :                               (bitmap_bit_p (live_relevant_regs, regno),
    4338                 :            :                                live_subregs, live_subregs_used, regno,
    4339                 :            :                                inner_size);
    4340                 :            : 
    4341                 :            :                             /* Ignore the paradoxical bits.  */
    4342                 :          0 :                             if (last > SBITMAP_SIZE (live_subregs[regno]))
    4343                 :            :                               last = SBITMAP_SIZE (live_subregs[regno]);
    4344                 :            : 
    4345                 :          0 :                             while (start < last)
    4346                 :            :                               {
    4347                 :          0 :                                 bitmap_set_bit (live_subregs[regno], start);
    4348                 :          0 :                                 start++;
    4349                 :            :                               }
    4350                 :            :                           }
    4351                 :            :                         else
    4352                 :            :                           /* Resetting the live_subregs_used is
    4353                 :            :                              effectively saying do not use the subregs
    4354                 :            :                              because we are reading the whole
    4355                 :            :                              pseudo.  */
    4356                 :          0 :                           bitmap_clear_bit (live_subregs_used, regno);
    4357                 :          0 :                         bitmap_set_bit (live_relevant_regs, regno);
    4358                 :            :                       }
    4359                 :            :                   }
    4360                 :            :             }
    4361                 :            :         }
    4362                 :            : 
    4363                 :            :       /* FIXME!! The following code is a disaster.  Reload needs to see the
    4364                 :            :          labels and jump tables that are just hanging out in between
    4365                 :            :          the basic blocks.  See pr33676.  */
    4366                 :          0 :       insn = BB_HEAD (bb);
    4367                 :            : 
    4368                 :            :       /* Skip over the barriers and cruft.  */
    4369                 :          0 :       while (insn && (BARRIER_P (insn) || NOTE_P (insn)
    4370                 :          0 :                       || BLOCK_FOR_INSN (insn) == bb))
    4371                 :          0 :         insn = PREV_INSN (insn);
    4372                 :            : 
    4373                 :            :       /* While we add anything except barriers and notes, the focus is
    4374                 :            :          to get the labels and jump tables into the
    4375                 :            :          reload_insn_chain.  */
    4376                 :          0 :       while (insn)
    4377                 :            :         {
    4378                 :          0 :           if (!NOTE_P (insn) && !BARRIER_P (insn))
    4379                 :            :             {
    4380                 :          0 :               if (BLOCK_FOR_INSN (insn))
    4381                 :            :                 break;
    4382                 :            : 
    4383                 :          0 :               c = new_insn_chain ();
    4384                 :          0 :               c->next = next;
    4385                 :          0 :               next = c;
    4386                 :          0 :               *p = c;
    4387                 :          0 :               p = &c->prev;
    4388                 :            : 
    4389                 :            :               /* The block makes no sense here, but it is what the old
    4390                 :            :                  code did.  */
    4391                 :          0 :               c->block = bb->index;
    4392                 :          0 :               c->insn = insn;
    4393                 :          0 :               bitmap_copy (&c->live_throughout, live_relevant_regs);
    4394                 :            :             }
    4395                 :          0 :           insn = PREV_INSN (insn);
    4396                 :            :         }
    4397                 :            :     }
    4398                 :            : 
    4399                 :          0 :   reload_insn_chain = c;
    4400                 :          0 :   *p = NULL;
    4401                 :            : 
    4402                 :          0 :   for (i = 0; i < (unsigned int) max_regno; i++)
    4403                 :          0 :     if (live_subregs[i] != NULL)
    4404                 :          0 :       sbitmap_free (live_subregs[i]);
    4405                 :          0 :   free (live_subregs);
    4406                 :            : 
    4407                 :          0 :   if (dump_file)
    4408                 :          0 :     print_insn_chains (dump_file);
    4409                 :          0 : }
    4410                 :            :  
    4411                 :            : /* Examine the rtx found in *LOC, which is read or written to as determined
    4412                 :            :    by TYPE.  Return false if we find a reason why an insn containing this
    4413                 :            :    rtx should not be moved (such as accesses to non-constant memory), true
    4414                 :            :    otherwise.  */
    4415                 :            : static bool
    4416                 :    3788840 : rtx_moveable_p (rtx *loc, enum op_type type)
    4417                 :            : {
    4418                 :    3798910 :   const char *fmt;
    4419                 :    3798910 :   rtx x = *loc;
    4420                 :    3798910 :   int i, j;
    4421                 :            : 
    4422                 :    3798910 :   enum rtx_code code = GET_CODE (x);
    4423                 :    3798910 :   switch (code)
    4424                 :            :     {
    4425                 :            :     case CONST:
    4426                 :            :     CASE_CONST_ANY:
    4427                 :            :     case SYMBOL_REF:
    4428                 :            :     case LABEL_REF:
    4429                 :            :       return true;
    4430                 :            : 
    4431                 :          0 :     case PC:
    4432                 :          0 :       return type == OP_IN;
    4433                 :            : 
    4434                 :          0 :     case CC0:
    4435                 :          0 :       return false;
    4436                 :            : 
    4437                 :    1390480 :     case REG:
    4438                 :    1390480 :       if (x == frame_pointer_rtx)
    4439                 :            :         return true;
    4440                 :    1390130 :       if (HARD_REGISTER_P (x))
    4441                 :     257759 :         return false;
    4442                 :            :       
    4443                 :            :       return true;
    4444                 :            : 
    4445                 :     399009 :     case MEM:
    4446                 :     399009 :       if (type == OP_IN && MEM_READONLY_P (x))
    4447                 :       9742 :         return rtx_moveable_p (&XEXP (x, 0), OP_IN);
    4448                 :            :       return false;
    4449                 :            : 
    4450                 :    1153890 :     case SET:
    4451                 :    1153890 :       return (rtx_moveable_p (&SET_SRC (x), OP_IN)
    4452                 :    1153890 :               && rtx_moveable_p (&SET_DEST (x), OP_OUT));
    4453                 :            : 
    4454                 :         73 :     case STRICT_LOW_PART:
    4455                 :         73 :       return rtx_moveable_p (&XEXP (x, 0), OP_OUT);
    4456                 :            : 
    4457                 :        197 :     case ZERO_EXTRACT:
    4458                 :        197 :     case SIGN_EXTRACT:
    4459                 :        197 :       return (rtx_moveable_p (&XEXP (x, 0), type)
    4460                 :        197 :               && rtx_moveable_p (&XEXP (x, 1), OP_IN)
    4461                 :        394 :               && rtx_moveable_p (&XEXP (x, 2), OP_IN));
    4462                 :            : 
    4463                 :        252 :     case CLOBBER:
    4464                 :        252 :       return rtx_moveable_p (&SET_DEST (x), OP_OUT);
    4465                 :            : 
    4466                 :       5290 :     case UNSPEC_VOLATILE:
    4467                 :            :       /* It is a bad idea to consider insns with such rtl
    4468                 :            :          as moveable ones.  The insn scheduler also considers them as barrier
    4469                 :            :          for a reason.  */
    4470                 :       5290 :       return false;
    4471                 :            : 
    4472                 :          0 :     case ASM_OPERANDS:
    4473                 :            :       /* The same is true for volatile asm: it has unknown side effects, it
    4474                 :            :          cannot be moved at will.  */
    4475                 :          0 :       if (MEM_VOLATILE_P (x))
    4476                 :            :         return false;
    4477                 :            : 
    4478                 :     527811 :     default:
    4479                 :     527811 :       break;
    4480                 :            :     }
    4481                 :            : 
    4482                 :     527811 :   fmt = GET_RTX_FORMAT (code);
    4483                 :    1345020 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    4484                 :            :     {
    4485                 :     897771 :       if (fmt[i] == 'e')
    4486                 :            :         {
    4487                 :     707212 :           if (!rtx_moveable_p (&XEXP (x, i), type))
    4488                 :            :             return false;
    4489                 :            :         }
    4490                 :     190559 :       else if (fmt[i] == 'E')
    4491                 :     327420 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    4492                 :            :           {
    4493                 :     254295 :             if (!rtx_moveable_p (&XVECEXP (x, i, j), type))
    4494                 :            :               return false;
    4495                 :            :           }
    4496                 :            :     }
    4497                 :            :   return true;
    4498                 :            : }
    4499                 :            : 
    4500                 :            : /* A wrapper around dominated_by_p, which uses the information in UID_LUID
    4501                 :            :    to give dominance relationships between two insns I1 and I2.  */
    4502                 :            : static bool
    4503                 :   14324900 : insn_dominated_by_p (rtx i1, rtx i2, int *uid_luid)
    4504                 :            : {
    4505                 :   14324900 :   basic_block bb1 = BLOCK_FOR_INSN (i1);
    4506                 :   14324900 :   basic_block bb2 = BLOCK_FOR_INSN (i2);
    4507                 :            : 
    4508                 :   14324900 :   if (bb1 == bb2)
    4509                 :    7324450 :     return uid_luid[INSN_UID (i2)] < uid_luid[INSN_UID (i1)];
    4510                 :    7000500 :   return dominated_by_p (CDI_DOMINATORS, bb1, bb2);
    4511                 :            : }
    4512                 :            : 
    4513                 :            : /* Record the range of register numbers added by find_moveable_pseudos.  */
    4514                 :            : int first_moveable_pseudo, last_moveable_pseudo;
    4515                 :            : 
    4516                 :            : /* These two vectors hold data for every register added by
    4517                 :            :    find_movable_pseudos, with index 0 holding data for the
    4518                 :            :    first_moveable_pseudo.  */
    4519                 :            : /* The original home register.  */
    4520                 :            : static vec<rtx> pseudo_replaced_reg;
    4521                 :            : 
    4522                 :            : /* Look for instances where we have an instruction that is known to increase
    4523                 :            :    register pressure, and whose result is not used immediately.  If it is
    4524                 :            :    possible to move the instruction downwards to just before its first use,
    4525                 :            :    split its lifetime into two ranges.  We create a new pseudo to compute the
    4526                 :            :    value, and emit a move instruction just before the first use.  If, after
    4527                 :            :    register allocation, the new pseudo remains unallocated, the function
    4528                 :            :    move_unallocated_pseudos then deletes the move instruction and places
    4529                 :            :    the computation just before the first use.
    4530                 :            : 
    4531                 :            :    Such a move is safe and profitable if all the input registers remain live
    4532                 :            :    and unchanged between the original computation and its first use.  In such
    4533                 :            :    a situation, the computation is known to increase register pressure, and
    4534                 :            :    moving it is known to at least not worsen it.
    4535                 :            : 
    4536                 :            :    We restrict moves to only those cases where a register remains unallocated,
    4537                 :            :    in order to avoid interfering too much with the instruction schedule.  As
    4538                 :            :    an exception, we may move insns which only modify their input register
    4539                 :            :    (typically induction variables), as this increases the freedom for our
    4540                 :            :    intended transformation, and does not limit the second instruction
    4541                 :            :    scheduler pass.  */
    4542                 :            :    
    4543                 :            : static void
    4544                 :     688548 : find_moveable_pseudos (void)
    4545                 :            : {
    4546                 :     688548 :   unsigned i;
    4547                 :     688548 :   int max_regs = max_reg_num ();
    4548                 :     688548 :   int max_uid = get_max_uid ();
    4549                 :     688548 :   basic_block bb;
    4550                 :     688548 :   int *uid_luid = XNEWVEC (int, max_uid);
    4551                 :     688548 :   rtx_insn **closest_uses = XNEWVEC (rtx_insn *, max_regs);
    4552                 :            :   /* A set of registers which are live but not modified throughout a block.  */
    4553                 :     688548 :   bitmap_head *bb_transp_live = XNEWVEC (bitmap_head,
    4554                 :            :                                          last_basic_block_for_fn (cfun));
    4555                 :            :   /* A set of registers which only exist in a given basic block.  */
    4556                 :     688548 :   bitmap_head *bb_local = XNEWVEC (bitmap_head,
    4557                 :            :                                    last_basic_block_for_fn (cfun));
    4558                 :            :   /* A set of registers which are set once, in an instruction that can be
    4559                 :            :      moved freely downwards, but are otherwise transparent to a block.  */
    4560                 :     688548 :   bitmap_head *bb_moveable_reg_sets = XNEWVEC (bitmap_head,
    4561                 :            :                                                last_basic_block_for_fn (cfun));
    4562                 :    1377100 :   auto_bitmap live, used, set, interesting, unusable_as_input;
    4563                 :     688548 :   bitmap_iterator bi;
    4564                 :            : 
    4565                 :     688548 :   first_moveable_pseudo = max_regs;
    4566                 :     688548 :   pseudo_replaced_reg.release ();
    4567                 :     688548 :   pseudo_replaced_reg.safe_grow_cleared (max_regs);
    4568                 :            : 
    4569                 :     688548 :   df_analyze ();
    4570                 :     688548 :   calculate_dominance_info (CDI_DOMINATORS);
    4571                 :            : 
    4572                 :     688548 :   i = 0;
    4573                 :    7674240 :   FOR_EACH_BB_FN (bb, cfun)
    4574                 :            :     {
    4575                 :    6985690 :       rtx_insn *insn;
    4576                 :    6985690 :       bitmap transp = bb_transp_live + bb->index;
    4577                 :    6985690 :       bitmap moveable = bb_moveable_reg_sets + bb->index;
    4578                 :    6985690 :       bitmap local = bb_local + bb->index;
    4579                 :            : 
    4580                 :    6985690 :       bitmap_initialize (local, 0);
    4581                 :    6985690 :       bitmap_initialize (transp, 0);
    4582                 :    6985690 :       bitmap_initialize (moveable, 0);
    4583                 :    6985690 :       bitmap_copy (live, df_get_live_out (bb));
    4584                 :    6985690 :       bitmap_and_into (live, df_get_live_in (bb));
    4585                 :    6985690 :       bitmap_copy (transp, live);
    4586                 :    6985690 :       bitmap_clear (moveable);
    4587                 :    6985690 :       bitmap_clear (live);
    4588                 :    6985690 :       bitmap_clear (used);
    4589                 :    6985690 :       bitmap_clear (set);
    4590                 :  166662000 :       FOR_BB_INSNS (bb, insn)
    4591                 :   79838000 :         if (NONDEBUG_INSN_P (insn))
    4592                 :            :           {
    4593                 :   38528300 :             df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4594                 :   38528300 :             df_ref def, use;
    4595                 :            : 
    4596                 :   38528300 :             uid_luid[INSN_UID (insn)] = i++;
    4597                 :            :             
    4598                 :   38528300 :             def = df_single_def (insn_info);
    4599                 :   38528300 :             use = df_single_use (insn_info);
    4600                 :   38528300 :             if (use
    4601                 :   38528300 :                 && def
    4602                 :   12938600 :                 && DF_REF_REGNO (use) == DF_REF_REGNO (def)
    4603                 :     517501 :                 && !bitmap_bit_p (set, DF_REF_REGNO (use))
    4604                 :   38578100 :                 && rtx_moveable_p (&PATTERN (insn), OP_IN))
    4605                 :            :               {
    4606                 :      14427 :                 unsigned regno = DF_REF_REGNO (use);
    4607                 :      14427 :                 bitmap_set_bit (moveable, regno);
    4608                 :      14427 :                 bitmap_set_bit (set, regno);
    4609                 :      14427 :                 bitmap_set_bit (used, regno);
    4610                 :      14427 :                 bitmap_clear_bit (transp, regno);
    4611                 :      14427 :                 continue;
    4612                 :            :               }
    4613                 :   85927600 :             FOR_EACH_INSN_INFO_USE (use, insn_info)
    4614                 :            :               {
    4615                 :   47413800 :                 unsigned regno = DF_REF_REGNO (use);
    4616                 :   47413800 :                 bitmap_set_bit (used, regno);
    4617                 :   47413800 :                 if (bitmap_clear_bit (moveable, regno))
    4618                 :       9656 :                   bitmap_clear_bit (transp, regno);
    4619                 :            :               }
    4620                 :            : 
    4621                 :  277044000 :             FOR_EACH_INSN_INFO_DEF (def, insn_info)
    4622                 :            :               {
    4623                 :  238531000 :                 unsigned regno = DF_REF_REGNO (def);
    4624                 :  238531000 :                 bitmap_set_bit (set, regno);
    4625                 :  238531000 :                 bitmap_clear_bit (transp, regno);
    4626                 :  238531000 :                 bitmap_clear_bit (moveable, regno);
    4627                 :            :               }
    4628                 :            :           }
    4629                 :            :     }
    4630                 :            : 
    4631                 :    7674240 :   FOR_EACH_BB_FN (bb, cfun)
    4632                 :            :     {
    4633                 :    6985690 :       bitmap local = bb_local + bb->index;
    4634                 :    6985690 :       rtx_insn *insn;
    4635                 :            : 
    4636                 :  166662000 :       FOR_BB_INSNS (bb, insn)
    4637                 :   79838000 :         if (NONDEBUG_INSN_P (insn))
    4638                 :            :           {
    4639                 :   38528300 :             df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
    4640                 :   38528300 :             rtx_insn *def_insn;
    4641                 :   38528300 :             rtx closest_use, note;
    4642                 :   38528300 :             df_ref def, use;
    4643                 :   38528300 :             unsigned regno;
    4644                 :   38528300 :             bool all_dominated, all_local;
    4645                 :   38528300 :             machine_mode mode;
    4646                 :            : 
    4647                 :   38528300 :             def = df_single_def (insn_info);
    4648                 :            :             /* There must be exactly one def in this insn.  */
    4649                 :   20902100 :             if (!def || !single_set (insn))
    4650                 :   17699600 :               continue;
    4651                 :            :             /* This must be the only definition of the reg.  We also limit
    4652                 :            :                which modes we deal with so that we can assume we can generate
    4653                 :            :                move instructions.  */
    4654                 :   20828700 :             regno = DF_REF_REGNO (def);
    4655                 :   20828700 :             mode = GET_MODE (DF_REF_REG (def));
    4656                 :   20828700 :             if (DF_REG_DEF_COUNT (regno) != 1
    4657                 :    8164480 :                 || !DF_REF_INSN_INFO (def)
    4658                 :    8164480 :                 || HARD_REGISTER_NUM_P (regno)
    4659                 :    8143240 :                 || DF_REG_EQ_USE_COUNT (regno) > 0
    4660                 :    7809670 :                 || (!INTEGRAL_MODE_P (mode) && !FLOAT_MODE_P (mode)))
    4661                 :   13019000 :               continue;
    4662                 :    7809670 :             def_insn = DF_REF_INSN (def);
    4663                 :            : 
    4664                 :   13167300 :             for (note = REG_NOTES (def_insn); note; note = XEXP (note, 1))
    4665                 :    6998060 :               if (REG_NOTE_KIND (note) == REG_EQUIV && MEM_P (XEXP (note, 0)))
    4666                 :            :                 break;
    4667                 :            :                 
    4668                 :    7809670 :             if (note)
    4669                 :            :               {
    4670                 :    1640410 :                 if (dump_file)
    4671                 :         68 :                   fprintf (dump_file, "Ignoring reg %d, has equiv memory\n",
    4672                 :            :                            regno);
    4673                 :    1640410 :                 bitmap_set_bit (unusable_as_input, regno);
    4674                 :    1640410 :                 continue;
    4675                 :            :               }
    4676                 :            : 
    4677                 :    6169260 :             use = DF_REG_USE_CHAIN (regno);
    4678                 :    6169260 :             all_dominated = true;
    4679                 :    6169260 :             all_local = true;
    4680                 :    6169260 :             closest_use = NULL_RTX;
    4681                 :   17950800 :             for (; use; use = DF_REF_NEXT_REG (use))
    4682                 :            :               {
    4683                 :   11781600 :                 rtx_insn *insn;
    4684                 :   11781600 :                 if (!DF_REF_INSN_INFO (use))
    4685                 :            :                   {
    4686                 :            :                     all_dominated = false;
    4687                 :            :                     all_local = false;
    4688                 :            :                     break;
    4689                 :            :                   }
    4690                 :   11781600 :                 insn = DF_REF_INSN (use);
    4691                 :   11781600 :                 if (DEBUG_INSN_P (insn))
    4692                 :    1359050 :                   continue;
    4693                 :   10422500 :                 if (BLOCK_FOR_INSN (insn) != BLOCK_FOR_INSN (def_insn))
    4694                 :    4242340 :                   all_local = false;
    4695                 :   10422500 :                 if (!insn_dominated_by_p (insn, def_insn, uid_luid))
    4696                 :       4894 :                   all_dominated = false;
    4697                 :   10422500 :                 if (closest_use != insn && closest_use != const0_rtx)
    4698                 :            :                   {
    4699                 :    9147330 :                     if (closest_use == NULL_RTX)
    4700                 :            :                       closest_use = insn;
    4701                 :    3015040 :                     else if (insn_dominated_by_p (closest_use, insn, uid_luid))
    4702                 :            :                       closest_use = insn;
    4703                 :     887376 :                     else if (!insn_dominated_by_p (insn, closest_use, uid_luid))
    4704                 :     421121 :                       closest_use = const0_rtx;
    4705                 :            :                   }
    4706                 :            :               }
    4707                 :    6169260 :             if (!all_dominated)
    4708                 :            :               {
    4709                 :       3457 :                 if (dump_file)
    4710                 :          0 :                   fprintf (dump_file, "Reg %d not all uses dominated by set\n",
    4711                 :            :                            regno);
    4712                 :       3457 :                 continue;
    4713                 :            :               }
    4714                 :    6165800 :             if (all_local)
    4715                 :    4340220 :               bitmap_set_bit (local, regno);
    4716                 :    5745480 :             if (closest_use == const0_rtx || closest_use == NULL
    4717                 :   11874300 :                 || next_nonnote_nondebug_insn (def_insn) == closest_use)
    4718                 :            :               {
    4719                 :    4172660 :                 if (dump_file)
    4720                 :        161 :                   fprintf (dump_file, "Reg %d uninteresting%s\n", regno,
    4721                 :        161 :                            closest_use == const0_rtx || closest_use == NULL
    4722                 :            :                            ? " (no unique first use)" : "");
    4723                 :    4172660 :                 continue;
    4724                 :            :               }
    4725                 :    1993130 :             if (HAVE_cc0 && reg_referenced_p (cc0_rtx, PATTERN (closest_use)))
    4726                 :            :               {
    4727                 :            :                 if (dump_file)
    4728                 :            :                   fprintf (dump_file, "Reg %d: closest user uses cc0\n",
    4729                 :            :                            regno);
    4730                 :            :                 continue;
    4731                 :            :               }
    4732                 :            : 
    4733                 :    1993130 :             bitmap_set_bit (interesting, regno);
    4734                 :            :             /* If we get here, we know closest_use is a non-NULL insn
    4735                 :            :                (as opposed to const_0_rtx).  */
    4736                 :    1993130 :             closest_uses[regno] = as_a <rtx_insn *> (closest_use);
    4737                 :            : 
    4738                 :    1993130 :             if (dump_file && (all_local || all_dominated))
    4739                 :            :               {
    4740                 :         76 :                 fprintf (dump_file, "Reg %u:", regno);
    4741                 :         76 :                 if (all_local)
    4742                 :         16 :                   fprintf (dump_file, " local to bb %d", bb->index);
    4743                 :         76 :                 if (all_dominated)
    4744                 :         76 :                   fprintf (dump_file, " def dominates all uses");
    4745                 :         76 :                 if (closest_use != const0_rtx)
    4746                 :         76 :                   fprintf (dump_file, " has unique first use");
    4747                 :         76 :                 fputs ("\n", dump_file);
    4748                 :            :               }
    4749                 :            :           }
    4750                 :            :     }
    4751                 :            : 
    4752                 :    2681680 :   EXECUTE_IF_SET_IN_BITMAP (interesting, 0, i, bi)
    4753                 :            :     {
    4754                 :    1993130 :       df_ref def = DF_REG_DEF_CHAIN (i);
    4755                 :    1993130 :       rtx_insn *def_insn = DF_REF_INSN (def);
    4756                 :    1993130 :       basic_block def_block = BLOCK_FOR_INSN (def_insn);
    4757                 :    1993130 :       bitmap def_bb_local = bb_local + def_block->index;
    4758                 :    1993130 :       bitmap def_bb_moveable = bb_moveable_reg_sets + def_block->index;
    4759                 :    1993130 :       bitmap def_bb_transp = bb_transp_live + def_block->index;
    4760                 :    1993130 :       bool local_to_bb_p = bitmap_bit_p (def_bb_local, i);
    4761                 :    1993130 :       rtx_insn *use_insn = closest_uses[i];
    4762                 :    1993130 :       df_ref use;
    4763                 :    1993130 :       bool all_ok = true;
    4764                 :    1993130 :       bool all_transp = true;
    4765                 :            : 
    4766                 :    1993130 :       if (!REG_P (DF_REF_REG (def)))
    4767                 :      16714 :         continue;
    4768                 :            : 
    4769                 :    1976420 :       if (!local_to_bb_p)
    4770                 :            :         {
    4771                 :     855383 :           if (dump_file)
    4772                 :         60 :             fprintf (dump_file, "Reg %u not local to one basic block\n",
    4773                 :            :                      i);
    4774                 :     855383 :           continue;
    4775                 :            :         }
    4776                 :    1121040 :       if (reg_equiv_init (i) != NULL_RTX)
    4777                 :            :         {
    4778                 :      16876 :           if (dump_file)
    4779                 :          0 :             fprintf (dump_file, "Ignoring reg %u with equiv init insn\n",
    4780                 :            :                      i);
    4781                 :      16876 :           continue;
    4782                 :            :         }
    4783                 :    1104160 :       if (!rtx_moveable_p (&PATTERN (def_insn), OP_IN))
    4784                 :            :         {
    4785                 :     616960 :           if (dump_file)
    4786                 :         16 :             fprintf (dump_file, "Found def insn %d for %d to be not moveable\n",
    4787                 :         16 :                      INSN_UID (def_insn), i);
    4788                 :     616960 :           continue;
    4789                 :            :         }
    4790                 :     487201 :       if (dump_file)
    4791                 :          0 :         fprintf (dump_file, "Examining insn %d, def for %d\n",
    4792                 :          0 :                  INSN_UID (def_insn), i);
    4793                 :    1034270 :       FOR_EACH_INSN_USE (use, def_insn)
    4794                 :            :         {
    4795                 :     590949 :           unsigned regno = DF_REF_REGNO (use);
    4796                 :     590949 :           if (bitmap_bit_p (unusable_as_input, regno))
    4797                 :            :             {
    4798                 :      43880 :               all_ok = false;
    4799                 :      43880 :               if (dump_file)
    4800                 :          0 :                 fprintf (dump_file, "  found unusable input reg %u.\n", regno);
    4801                 :            :               break;
    4802                 :            :             }
    4803                 :     547069 :           if (!bitmap_bit_p (def_bb_transp, regno))
    4804                 :            :             {
    4805                 :     516883 :               if (bitmap_bit_p (def_bb_moveable, regno)
    4806                 :         23 :                   && !control_flow_insn_p (use_insn)
    4807                 :     516883 :                   && (!HAVE_cc0 || !sets_cc0_p (use_insn)))
    4808                 :            :                 {
    4809                 :         23 :                   if (modified_between_p (DF_REF_REG (use), def_insn, use_insn))
    4810                 :            :                     {
    4811                 :          1 :                       rtx_insn *x = NEXT_INSN (def_insn);
    4812                 :          1 :                       while (!modified_in_p (DF_REF_REG (use), x))
    4813                 :            :                         {
    4814                 :          0 :                           gcc_assert (x != use_insn);
    4815                 :          0 :                           x = NEXT_INSN (x);
    4816                 :            :                         }
    4817                 :          1 :                       if (dump_file)
    4818                 :          0 :                         fprintf (dump_file, "  input reg %u modified but insn %d moveable\n",
    4819                 :          0 :                                  regno, INSN_UID (x));
    4820                 :          1 :                       emit_insn_after (PATTERN (x), use_insn);
    4821                 :          1 :                       set_insn_deleted (x);
    4822                 :            :                     }
    4823                 :            :                   else
    4824                 :            :                     {
    4825                 :         22 :                       if (dump_file)
    4826                 :          0 :                         fprintf (dump_file, "  input reg %u modified between def and use\n",
    4827                 :            :                                  regno);
    4828                 :            :                       all_transp = false;
    4829                 :            :                     }
    4830                 :            :                 }
    4831                 :            :               else
    4832                 :            :                 all_transp = false;
    4833                 :            :             }
    4834                 :            :         }
    4835                 :          0 :       if (!all_ok)
    4836                 :      43880 :         continue;
    4837                 :     443321 :       if (!dbg_cnt (ira_move))
    4838                 :            :         break;
    4839                 :     443321 :       if (dump_file)
    4840                 :          0 :         fprintf (dump_file, "  all ok%s\n", all_transp ? " and transp" : "");
    4841                 :            : 
    4842                 :     443321 :       if (all_transp)
    4843                 :            :         {
    4844                 :      10980 :           rtx def_reg = DF_REF_REG (def);
    4845                 :      10980 :           rtx newreg = ira_create_new_reg (def_reg);
    4846                 :      10980 :           if (validate_change (def_insn, DF_REF_REAL_LOC (def), newreg, 0))
    4847                 :            :             {
    4848                 :      10980 :               unsigned nregno = REGNO (newreg);
    4849                 :      10980 :               emit_insn_before (gen_move_insn (def_reg, newreg), use_insn);
    4850                 :      10980 :               nregno -= max_regs;
    4851                 :      10980 :               pseudo_replaced_reg[nregno] = def_reg;
    4852                 :            :             }
    4853                 :            :         }
    4854                 :            :     }
    4855                 :            :   
    4856                 :    7674240 :   FOR_EACH_BB_FN (bb, cfun)
    4857                 :            :     {
    4858                 :    6985690 :       bitmap_clear (bb_local + bb->index);
    4859                 :    6985690 :       bitmap_clear (bb_transp_live + bb->index);
    4860                 :    6985690 :       bitmap_clear (bb_moveable_reg_sets + bb->index);
    4861                 :            :     }
    4862                 :     688548 :   free (uid_luid);
    4863                 :     688548 :   free (closest_uses);
    4864                 :     688548 :   free (bb_local);
    4865                 :     688548 :   free (bb_transp_live);
    4866                 :     688548 :   free (bb_moveable_reg_sets);
    4867                 :            : 
    4868                 :     688548 :   last_moveable_pseudo = max_reg_num ();
    4869                 :            : 
    4870                 :     688548 :   fix_reg_equiv_init ();
    4871                 :     688548 :   expand_reg_info ();
    4872                 :     688548 :   regstat_free_n_sets_and_refs ();
    4873                 :     688548 :   regstat_free_ri ();
    4874                 :     688548 :   regstat_init_n_sets_and_refs ();
    4875                 :     688548 :   regstat_compute_ri ();
    4876                 :     688548 :   free_dominance_info (CDI_DOMINATORS);
    4877                 :     688548 : }
    4878                 :            : 
    4879                 :            : /* If SET pattern SET is an assignment from a hard register to a pseudo which
    4880                 :            :    is live at CALL_DOM (if non-NULL, otherwise this check is omitted), return
    4881                 :            :    the destination.  Otherwise return NULL.  */
    4882                 :            : 
    4883                 :            : static rtx
    4884                 :    1956560 : interesting_dest_for_shprep_1 (rtx set, basic_block call_dom)
    4885                 :            : {
    4886                 :    1956560 :   rtx src = SET_SRC (set);
    4887                 :    1956560 :   rtx dest = SET_DEST (set);
    4888                 :     804711 :   if (!REG_P (src) || !HARD_REGISTER_P (src)
    4889                 :     410315 :       || !REG_P (dest) || HARD_REGISTER_P (dest)
    4890                 :    2351770 :       || (call_dom && !bitmap_bit_p (df_get_live_in (call_dom), REGNO (dest))))
    4891                 :    1693110 :     return NULL;
    4892                 :            :   return dest;
    4893                 :            : }
    4894                 :            : 
    4895                 :            : /* If insn is interesting for parameter range-splitting shrink-wrapping
    4896                 :            :    preparation, i.e. it is a single set from a hard register to a pseudo, which
    4897                 :            :    is live at CALL_DOM (if non-NULL, otherwise this check is omitted), or a
    4898                 :            :    parallel statement with only one such statement, return the destination.
    4899                 :            :    Otherwise return NULL.  */
    4900                 :            : 
    4901                 :            : static rtx
    4902                 :    3799460 : interesting_dest_for_shprep (rtx_insn *insn, basic_block call_dom)
    4903                 :            : {
    4904                 :    3799460 :   if (!INSN_P (insn))
    4905                 :            :     return NULL;
    4906                 :    3119000 :   rtx pat = PATTERN (insn);
    4907                 :    3119000 :   if (GET_CODE (pat) == SET)
    4908                 :    1760750 :     return interesting_dest_for_shprep_1 (pat, call_dom);
    4909                 :            : 
    4910                 :    1358250 :   if (GET_CODE (pat) != PARALLEL)
    4911                 :            :     return NULL;
    4912                 :            :   rtx ret = NULL;
    4913                 :     500476 :   for (int i = 0; i < XVECLEN (pat, 0); i++)
    4914                 :            :     {
    4915                 :     341020 :       rtx sub = XVECEXP (pat, 0, i);
    4916                 :     341020 :       if (GET_CODE (sub) == USE || GET_CODE (sub) == CLOBBER)
    4917                 :     141356 :         continue;
    4918                 :     199664 :       if (GET_CODE (sub) != SET
    4919                 :     199664 :           || side_effects_p (sub))
    4920                 :       3850 :         return NULL;
    4921                 :     195814 :       rtx dest = interesting_dest_for_shprep_1 (sub, call_dom);
    4922                 :     195814 :       if (dest && ret)
    4923                 :            :         return NULL;
    4924                 :     195814 :       if (dest)
    4925                 :          0 :         ret = dest;
    4926                 :            :     }
    4927                 :            :   return ret;
    4928                 :            : }
    4929                 :            : 
    4930                 :            : /* Split live ranges of pseudos that are loaded from hard registers in the
    4931                 :            :    first BB in a BB that dominates all non-sibling call if such a BB can be
    4932                 :            :    found and is not in a loop.  Return true if the function has made any
    4933                 :            :    changes.  */
    4934                 :            : 
    4935                 :            : static bool
    4936                 :     688548 : split_live_ranges_for_shrink_wrap (void)
    4937                 :            : {
    4938                 :     688548 :   basic_block bb, call_dom = NULL;
    4939                 :     688548 :   basic_block first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    4940                 :     688548 :   rtx_insn *insn, *last_interesting_insn = NULL;
    4941                 :    1377100 :   auto_bitmap need_new, reachable;
    4942                 :     688548 :   vec<basic_block> queue;
    4943                 :            : 
    4944                 :     688548 :   if (!SHRINK_WRAPPING_ENABLED)
    4945                 :        124 :     return false;
    4946                 :            : 
    4947                 :     688424 :   queue.create (n_basic_blocks_for_fn (cfun));
    4948                 :            : 
    4949                 :    4902100 :   FOR_EACH_BB_FN (bb, cfun)
    4950                 :   88239100 :     FOR_BB_INSNS (bb, insn)
    4951                 :   43093500 :       if (CALL_P (insn) && !SIBLING_CALL_P (insn))
    4952                 :            :         {
    4953                 :    1205730 :           if (bb == first)
    4954                 :            :             {
    4955                 :     249868 :               queue.release ();
    4956                 :     249868 :               return false;
    4957                 :            :             }
    4958                 :            : 
    4959                 :     955863 :           bitmap_set_bit (need_new, bb->index);
    4960                 :     955863 :           bitmap_set_bit (reachable, bb->index);
    4961                 :    5169540 :           queue.quick_push (bb);
    4962                 :            :           break;
    4963                 :            :         }
    4964                 :            : 
    4965                 :     438556 :   if (queue.is_empty ())
    4966                 :            :     {
    4967                 :     253455 :       queue.release ();
    4968                 :     253455 :       return false;
    4969                 :            :     }
    4970                 :            : 
    4971                 :    2721550 :   while (!queue.is_empty ())
    4972                 :            :     {
    4973                 :    2536450 :       edge e;
    4974                 :    2536450 :       edge_iterator ei;
    4975                 :            : 
    4976                 :    2536450 :       bb = queue.pop ();
    4977                 :    6050380 :       FOR_EACH_EDGE (e, ei, bb->succs)
    4978                 :    3513940 :         if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
    4979                 :    3513940 :             && bitmap_set_bit (reachable, e->dest->index))
    4980                 :    5094520 :           queue.quick_push (e->dest);
    4981                 :            :     }
    4982                 :     185101 :   queue.release ();
    4983                 :            : 
    4984                 :    5875160 :   FOR_BB_INSNS (first, insn)
    4985                 :            :     {
    4986                 :    2845140 :       rtx dest = interesting_dest_for_shprep (insn, NULL);
    4987                 :    2845140 :       if (!dest)
    4988                 :    2582460 :         continue;
    4989                 :            : 
    4990                 :     262676 :       if (DF_REG_DEF_COUNT (REGNO (dest)) > 1)
    4991                 :            :         return false;
    4992                 :            : 
    4993                 :     262572 :       for (df_ref use = DF_REG_USE_CHAIN (REGNO(dest));
    4994                 :     547742 :            use;
    4995                 :     285170 :            use = DF_REF_NEXT_REG (use))
    4996                 :            :         {
    4997                 :     285170 :           int ubbi = DF_REF_BB (use)->index;
    4998                 :     285170 :           if (bitmap_bit_p (reachable, ubbi))
    4999                 :       1664 :             bitmap_set_bit (need_new, ubbi);
    5000                 :            :         }
    5001                 :            :       last_interesting_insn = insn;
    5002                 :            :     }
    5003                 :            : 
    5004                 :     184997 :   if (!last_interesting_insn)
    5005                 :            :     return false;
    5006                 :            : 
    5007                 :     127537 :   call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, need_new);
    5008                 :     127537 :   if (call_dom == first)
    5009                 :            :     return false;
    5010                 :            : 
    5011                 :      83393 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    5012                 :     103103 :   while (bb_loop_depth (call_dom) > 0)
    5013                 :      19710 :     call_dom = get_immediate_dominator (CDI_DOMINATORS, call_dom);
    5014                 :      83393 :   loop_optimizer_finalize ();
    5015                 :            : 
    5016                 :      83393 :   if (call_dom == first)
    5017                 :            :     return false;
    5018                 :            : 
    5019                 :      75963 :   calculate_dominance_info (CDI_POST_DOMINATORS);
    5020                 :      75963 :   if (dominated_by_p (CDI_POST_DOMINATORS, first, call_dom))
    5021                 :            :     {
    5022                 :       5873 :       free_dominance_info (CDI_POST_DOMINATORS);
    5023                 :       5873 :       return false;
    5024                 :            :     }
    5025                 :      70090 :   free_dominance_info (CDI_POST_DOMINATORS);
    5026                 :            : 
    5027                 :      70090 :   if (dump_file)
    5028                 :          5 :     fprintf (dump_file, "Will split live ranges of parameters at BB %i\n",
    5029                 :            :              call_dom->index);
    5030                 :            : 
    5031                 :      70090 :   bool ret = false;
    5032                 :    1977190 :   FOR_BB_INSNS (first, insn)
    5033                 :            :     {
    5034                 :     954323 :       rtx dest = interesting_dest_for_shprep (insn, call_dom);
    5035                 :     954323 :       if (!dest || dest == pic_offset_table_rtx)
    5036                 :     953549 :         continue;
    5037                 :            : 
    5038                 :        774 :       bool need_newreg = false;
    5039                 :        774 :       df_ref use, next;
    5040                 :        774 :       for (use = DF_REG_USE_CHAIN (REGNO (dest)); use; use = next)
    5041                 :            :         {
    5042                 :        774 :           rtx_insn *uin = DF_REF_INSN (use);
    5043                 :        774 :           next = DF_REF_NEXT_REG (use);
    5044                 :            : 
    5045                 :        774 :           if (DEBUG_INSN_P (uin))
    5046                 :          0 :             continue;
    5047                 :            : 
    5048                 :        774 :           basic_block ubb = BLOCK_FOR_INSN (uin);
    5049                 :        774 :           if (ubb == call_dom
    5050                 :        774 :               || dominated_by_p (CDI_DOMINATORS, ubb, call_dom))
    5051                 :            :             {
    5052                 :            :               need_newreg = true;
    5053                 :            :               break;
    5054                 :            :             }
    5055                 :            :         }
    5056                 :            : 
    5057                 :        774 :       if (need_newreg)
    5058                 :            :         {
    5059                 :        774 :           rtx newreg = ira_create_new_reg (dest);
    5060                 :            : 
    5061                 :       2317 :           for (use = DF_REG_USE_CHAIN (REGNO (dest)); use; use = next)
    5062                 :            :             {
    5063                 :       1543 :               rtx_insn *uin = DF_REF_INSN (use);
    5064                 :       1543 :               next = DF_REF_NEXT_REG (use);
    5065                 :            : 
    5066                 :       1543 :               basic_block ubb = BLOCK_FOR_INSN (uin);
    5067                 :       1543 :               if (ubb == call_dom
    5068                 :       1543 :                   || dominated_by_p (CDI_DOMINATORS, ubb, call_dom))
    5069                 :        774 :                 validate_change (uin, DF_REF_REAL_LOC (use), newreg, true);
    5070                 :            :             }
    5071                 :            : 
    5072                 :        774 :           rtx_insn *new_move = gen_move_insn (newreg, dest);
    5073                 :        774 :           emit_insn_after (new_move, bb_note (call_dom));
    5074                 :        774 :           if (dump_file)
    5075                 :            :             {
    5076                 :          0 :               fprintf (dump_file, "Split live-range of register ");
    5077                 :          0 :               print_rtl_single (dump_file, dest);
    5078                 :            :             }
    5079                 :            :           ret = true;
    5080                 :            :         }
    5081                 :            : 
    5082                 :        774 :       if (insn == last_interesting_insn)
    5083                 :            :         break;
    5084                 :            :     }
    5085                 :      70090 :   apply_change_group ();
    5086                 :      70090 :   return ret;
    5087                 :            : }
    5088                 :            : 
    5089                 :            : /* Perform the second half of the transformation started in
    5090                 :            :    find_moveable_pseudos.  We look for instances where the newly introduced
    5091                 :            :    pseudo remains unallocated, and remove it by moving the definition to
    5092                 :            :    just before its use, replacing the move instruction generated by
    5093                 :            :    find_moveable_pseudos.  */
    5094                 :            : static void
    5095                 :     688548 : move_unallocated_pseudos (void)
    5096                 :            : {
    5097                 :     688548 :   int i;
    5098                 :     699528 :   for (i = first_moveable_pseudo; i < last_moveable_pseudo; i++)
    5099                 :      10980 :     if (reg_renumber[i] < 0)
    5100                 :            :       {
    5101                 :       1881 :         int idx = i - first_moveable_pseudo;
    5102                 :       1881 :         rtx other_reg = pseudo_replaced_reg[idx];
    5103                 :       1881 :         rtx_insn *def_insn = DF_REF_INSN (DF_REG_DEF_CHAIN (i));
    5104                 :            :         /* The use must follow all definitions of OTHER_REG, so we can
    5105                 :            :            insert the new definition immediately after any of them.  */
    5106                 :       1881 :         df_ref other_def = DF_REG_DEF_CHAIN (REGNO (other_reg));
    5107                 :       1881 :         rtx_insn *move_insn = DF_REF_INSN (other_def);
    5108                 :       1881 :         rtx_insn *newinsn = emit_insn_after (PATTERN (def_insn), move_insn);
    5109                 :       1881 :         rtx set;
    5110                 :       1881 :         int success;
    5111                 :            : 
    5112                 :       1881 :         if (dump_file)
    5113                 :          0 :           fprintf (dump_file, "moving def of %d (insn %d now) ",
    5114                 :          0 :                    REGNO (other_reg), INSN_UID (def_insn));
    5115                 :            : 
    5116                 :       1881 :         delete_insn (move_insn);
    5117                 :       1881 :         while ((other_def = DF_REG_DEF_CHAIN (REGNO (other_reg))))
    5118                 :          0 :           delete_insn (DF_REF_INSN (other_def));
    5119                 :       1881 :         delete_insn (def_insn);
    5120                 :            : 
    5121                 :       1881 :         set = single_set (newinsn);
    5122                 :       1881 :         success = validate_change (newinsn, &SET_DEST (set), other_reg, 0);
    5123                 :       1881 :         gcc_assert (success);
    5124                 :       1881 :         if (dump_file)
    5125                 :          0 :           fprintf (dump_file, " %d) rather than keep unallocated replacement %d\n",
    5126                 :          0 :                    INSN_UID (newinsn), i);
    5127                 :       1881 :         SET_REG_N_REFS (i, 0);
    5128                 :            :       }
    5129                 :     688548 : }
    5130                 :            : 
    5131                 :            : /* If the backend knows where to allocate pseudos for hard
    5132                 :            :    register initial values, register these allocations now.  */
    5133                 :            : static void
    5134                 :     944096 : allocate_initial_values (void)
    5135                 :            : {
    5136                 :     944096 :   if (targetm.allocate_initial_value)
    5137                 :            :     {
    5138                 :            :       rtx hreg, preg, x;
    5139                 :            :       int i, regno;
    5140                 :            : 
    5141                 :          0 :       for (i = 0; HARD_REGISTER_NUM_P (i); i++)
    5142                 :            :         {
    5143                 :          0 :           if (! initial_value_entry (i, &hreg, &preg))
    5144                 :            :             break;
    5145                 :            : 
    5146                 :          0 :           x = targetm.allocate_initial_value (hreg);
    5147                 :          0 :           regno = REGNO (preg);
    5148                 :          0 :           if (x && REG_N_SETS (regno) <= 1)
    5149                 :            :             {
    5150                 :          0 :               if (MEM_P (x))
    5151                 :          0 :                 reg_equiv_memory_loc (regno) = x;
    5152                 :            :               else
    5153                 :            :                 {
    5154                 :          0 :                   basic_block bb;
    5155                 :          0 :                   int new_regno;
    5156                 :            : 
    5157                 :          0 :                   gcc_assert (REG_P (x));
    5158                 :          0 :                   new_regno = REGNO (x);
    5159                 :          0 :                   reg_renumber[regno] = new_regno;
    5160                 :            :                   /* Poke the regno right into regno_reg_rtx so that even
    5161                 :            :                      fixed regs are accepted.  */
    5162                 :          0 :                   SET_REGNO (preg, new_regno);
    5163                 :            :                   /* Update global register liveness information.  */
    5164                 :          0 :                   FOR_EACH_BB_FN (bb, cfun)
    5165                 :            :                     {
    5166                 :          0 :                       if (REGNO_REG_SET_P (df_get_live_in (bb), regno))
    5167                 :          0 :                         SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
    5168                 :          0 :                       if (REGNO_REG_SET_P (df_get_live_out (bb), regno))
    5169                 :          0 :                         SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
    5170                 :            :                     }
    5171                 :            :                 }
    5172                 :            :             }
    5173                 :            :         }
    5174                 :            : 
    5175                 :          0 :       gcc_checking_assert (! initial_value_entry (FIRST_PSEUDO_REGISTER,
    5176                 :            :                                                   &hreg, &preg));
    5177                 :            :     }
    5178                 :     944096 : }
    5179                 :            : 
    5180                 :            : 
    5181                 :            : /* True when we use LRA instead of reload pass for the current
    5182                 :            :    function.  */
    5183                 :            : bool ira_use_lra_p;
    5184                 :            : 
    5185                 :            : /* True if we have allocno conflicts.  It is false for non-optimized
    5186                 :            :    mode or when the conflict table is too big.  */
    5187                 :            : bool ira_conflicts_p;
    5188                 :            : 
    5189                 :            : /* Saved between IRA and reload.  */
    5190                 :            : static int saved_flag_ira_share_spill_slots;
    5191                 :            : 
    5192                 :            : /* This is the main entry of IRA.  */
    5193                 :            : static void
    5194                 :     944096 : ira (FILE *f)
    5195                 :            : {
    5196                 :     944096 :   bool loops_p;
    5197                 :     944096 :   int ira_max_point_before_emit;
    5198                 :     944096 :   bool saved_flag_caller_saves = flag_caller_saves;
    5199                 :     944096 :   enum ira_region saved_flag_ira_region = flag_ira_region;
    5200                 :            : 
    5201                 :     944096 :   clear_bb_flags ();
    5202                 :            : 
    5203                 :            :   /* Determine if the current function is a leaf before running IRA
    5204                 :            :      since this can impact optimizations done by the prologue and
    5205                 :            :      epilogue thus changing register elimination offsets.
    5206                 :            :      Other target callbacks may use crtl->is_leaf too, including
    5207                 :            :      SHRINK_WRAPPING_ENABLED, so initialize as early as possible.  */
    5208                 :     944096 :   crtl->is_leaf = leaf_function_p ();
    5209                 :            : 
    5210                 :            :   /* Perform target specific PIC register initialization.  */
    5211                 :     944096 :   targetm.init_pic_reg ();
    5212                 :            : 
    5213                 :     944096 :   ira_conflicts_p = optimize > 0;
    5214                 :            : 
    5215                 :            :   /* Determine the number of pseudos actually requiring coloring.  */
    5216                 :     944096 :   unsigned int num_used_regs = 0;
    5217                 :   41070800 :   for (unsigned int i = FIRST_PSEUDO_REGISTER; i < DF_REG_SIZE (df); i++)
    5218                 :   40126800 :     if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i))
    5219                 :   18089100 :       num_used_regs++;
    5220                 :            : 
    5221                 :            :   /* If there are too many pseudos and/or basic blocks (e.g. 10K
    5222                 :            :      pseudos and 10K blocks or 100K pseudos and 1K blocks), we will
    5223                 :            :      use simplified and faster algorithms in LRA.  */
    5224                 :     944096 :   lra_simple_p
    5225                 :     944096 :     = ira_use_lra_p
    5226                 :     944096 :       && num_used_regs >= (1U << 26) / last_basic_block_for_fn (cfun);
    5227                 :            : 
    5228                 :     944096 :   if (lra_simple_p)
    5229                 :            :     {
    5230                 :            :       /* It permits to skip live range splitting in LRA.  */
    5231                 :          7 :       flag_caller_saves = false;
    5232                 :            :       /* There is no sense to do regional allocation when we use
    5233                 :            :         simplified LRA.  */
    5234                 :          7 :       flag_ira_region = IRA_REGION_ONE;
    5235                 :          7 :       ira_conflicts_p = false;
    5236                 :            :     }
    5237                 :            : 
    5238                 :            : #ifndef IRA_NO_OBSTACK
    5239                 :            :   gcc_obstack_init (&ira_obstack);
    5240                 :            : #endif
    5241                 :     944096 :   bitmap_obstack_initialize (&ira_bitmap_obstack);
    5242                 :            : 
    5243                 :            :   /* LRA uses its own infrastructure to handle caller save registers.  */
    5244                 :     944096 :   if (flag_caller_saves && !ira_use_lra_p)
    5245                 :          0 :     init_caller_save ();
    5246                 :            : 
    5247                 :     944096 :   if (flag_ira_verbose < 10)
    5248                 :            :     {
    5249                 :     944096 :       internal_flag_ira_verbose = flag_ira_verbose;
    5250                 :     944096 :       ira_dump_file = f;
    5251                 :            :     }
    5252                 :            :   else
    5253                 :            :     {
    5254                 :          0 :       internal_flag_ira_verbose = flag_ira_verbose - 10;
    5255                 :          0 :       ira_dump_file = stderr;
    5256                 :            :     }
    5257                 :            : 
    5258                 :     944096 :   setup_prohibited_mode_move_regs ();
    5259                 :     944096 :   decrease_live_ranges_number ();
    5260                 :     944096 :   df_note_add_problem ();
    5261                 :            : 
    5262                 :            :   /* DF_LIVE can't be used in the register allocator, too many other
    5263                 :            :      parts of the compiler depend on using the "classic" liveness
    5264                 :            :      interpretation of the DF_LR problem.  See PR38711.
    5265                 :            :      Remove the problem, so that we don't spend time updating it in
    5266                 :            :      any of the df_analyze() calls during IRA/LRA.  */
    5267                 :     944096 :   if (optimize > 1)
    5268                 :     645364 :     df_remove_problem (df_live);
    5269                 :     944096 :   gcc_checking_assert (df_live == NULL);
    5270                 :            : 
    5271                 :     944096 :   if (flag_checking)
    5272                 :     944084 :     df->changeable_flags |= DF_VERIFY_SCHEDULED;
    5273                 :            : 
    5274                 :     944096 :   df_analyze ();
    5275                 :            : 
    5276                 :     944096 :   init_reg_equiv ();
    5277                 :     944096 :   if (ira_conflicts_p)
    5278                 :            :     {
    5279                 :     688548 :       calculate_dominance_info (CDI_DOMINATORS);
    5280                 :            : 
    5281                 :     688548 :       if (split_live_ranges_for_shrink_wrap ())
    5282                 :        774 :         df_analyze ();
    5283                 :            : 
    5284                 :     688548 :       free_dominance_info (CDI_DOMINATORS);
    5285                 :            :     }
    5286                 :            : 
    5287                 :     944096 :   df_clear_flags (DF_NO_INSN_RESCAN);
    5288                 :            : 
    5289                 :     944096 :   indirect_jump_optimize ();
    5290                 :     944096 :   if (delete_trivially_dead_insns (get_insns (), max_reg_num ()))
    5291                 :       2302 :     df_analyze ();
    5292                 :            : 
    5293                 :     944096 :   regstat_init_n_sets_and_refs ();
    5294                 :     944096 :   regstat_compute_ri ();
    5295                 :            : 
    5296                 :            :   /* If we are not optimizing, then this is the only place before
    5297                 :            :      register allocation where dataflow is done.  And that is needed
    5298                 :            :      to generate these warnings.  */
    5299                 :     944096 :   if (warn_clobbered)
    5300                 :      41302 :     generate_setjmp_warnings ();
    5301                 :            : 
    5302                 :     944096 :   if (resize_reg_info () && flag_ira_loop_pressure)
    5303                 :          2 :     ira_set_pseudo_classes (true, ira_dump_file);
    5304                 :            : 
    5305                 :     944096 :   init_alias_analysis ();
    5306                 :     944096 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    5307                 :     944096 :   reg_equiv = XCNEWVEC (struct equivalence, max_reg_num ());
    5308                 :     944096 :   update_equiv_regs_prescan ();
    5309                 :     944096 :   update_equiv_regs ();
    5310                 :            : 
    5311                 :            :   /* Don't move insns if live range shrinkage or register
    5312                 :            :      pressure-sensitive scheduling were done because it will not
    5313                 :            :      improve allocation but likely worsen insn scheduling.  */
    5314                 :     944096 :   if (optimize
    5315                 :     688548 :       && !flag_live_range_shrinkage
    5316                 :     688528 :       && !(flag_sched_pressure && flag_schedule_insns))
    5317                 :     688467 :     combine_and_move_insns ();
    5318                 :            : 
    5319                 :            :   /* Gather additional equivalences with memory.  */
    5320                 :     944096 :   if (optimize)
    5321                 :     688548 :     add_store_equivs ();
    5322                 :            : 
    5323                 :     944096 :   loop_optimizer_finalize ();
    5324                 :     944096 :   free_dominance_info (CDI_DOMINATORS);
    5325                 :     944096 :   end_alias_analysis ();
    5326                 :     944096 :   free (reg_equiv);
    5327                 :            : 
    5328                 :     944096 :   setup_reg_equiv ();
    5329                 :     944096 :   grow_reg_equivs ();
    5330                 :     944096 :   setup_reg_equiv_init ();
    5331                 :            : 
    5332                 :     944096 :   allocated_reg_info_size = max_reg_num ();
    5333                 :            : 
    5334                 :            :   /* It is not worth to do such improvement when we use a simple
    5335                 :            :      allocation because of -O0 usage or because the function is too
    5336                 :            :      big.  */
    5337                 :     944096 :   if (ira_conflicts_p)
    5338                 :     688548 :     find_moveable_pseudos ();
    5339                 :            : 
    5340                 :     944096 :   max_regno_before_ira = max_reg_num ();
    5341                 :     944096 :   ira_setup_eliminable_regset ();
    5342                 :            : 
    5343                 :     944096 :   ira_overall_cost = ira_reg_cost = ira_mem_cost = 0;
    5344                 :     944096 :   ira_load_cost = ira_store_cost = ira_shuffle_cost = 0;
    5345                 :     944096 :   ira_move_loops_num = ira_additional_jumps_num = 0;
    5346                 :            : 
    5347                 :     944096 :   ira_assert (current_loops == NULL);
    5348                 :     944096 :   if (flag_ira_region == IRA_REGION_ALL || flag_ira_region == IRA_REGION_MIXED)
    5349                 :     660335 :     loop_optimizer_init (AVOID_CFG_MODIFICATIONS | LOOPS_HAVE_RECORDED_EXITS);
    5350                 :            : 
    5351                 :     944096 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    5352                 :        102 :     fprintf (ira_dump_file, "Building IRA IR\n");
    5353                 :     944096 :   loops_p = ira_build ();
    5354                 :            : 
    5355                 :     944096 :   ira_assert (ira_conflicts_p || !loops_p);
    5356                 :            : 
    5357                 :     944096 :   saved_flag_ira_share_spill_slots = flag_ira_share_spill_slots;
    5358                 :    1888190 :   if (too_high_register_pressure_p () || cfun->calls_setjmp)
    5359                 :            :     /* It is just wasting compiler's time to pack spilled pseudos into
    5360                 :            :        stack slots in this case -- prohibit it.  We also do this if
    5361                 :            :        there is setjmp call because a variable not modified between
    5362                 :            :        setjmp and longjmp the compiler is required to preserve its
    5363                 :            :        value and sharing slots does not guarantee it.  */
    5364                 :        972 :     flag_ira_share_spill_slots = FALSE;
    5365                 :            : 
    5366                 :     944096 :   ira_color ();
    5367                 :            : 
    5368                 :     944096 :   ira_max_point_before_emit = ira_max_point;
    5369                 :            : 
    5370                 :     944096 :   ira_initiate_emit_data ();
    5371                 :            : 
    5372                 :     944096 :   ira_emit (loops_p);
    5373                 :            : 
    5374                 :     944096 :   max_regno = max_reg_num ();
    5375                 :     944096 :   if (ira_conflicts_p)
    5376                 :            :     {
    5377                 :     688548 :       if (! loops_p)
    5378                 :            :         {
    5379                 :     663128 :           if (! ira_use_lra_p)
    5380                 :          0 :             ira_initiate_assign ();
    5381                 :            :         }
    5382                 :            :       else
    5383                 :            :         {
    5384                 :      25420 :           expand_reg_info ();
    5385                 :            : 
    5386                 :      25420 :           if (ira_use_lra_p)
    5387                 :            :             {
    5388                 :            :               ira_allocno_t a;
    5389                 :            :               ira_allocno_iterator ai;
    5390                 :            : 
    5391                 :    8049210 :               FOR_EACH_ALLOCNO (a, ai)
    5392                 :            :                 {
    5393                 :    8023790 :                   int old_regno = ALLOCNO_REGNO (a);
    5394                 :    8023790 :                   int new_regno = REGNO (ALLOCNO_EMIT_DATA (a)->reg);
    5395                 :            : 
    5396                 :    8023790 :                   ALLOCNO_REGNO (a) = new_regno;
    5397                 :            : 
    5398                 :    8023790 :                   if (old_regno != new_regno)
    5399                 :     671809 :                     setup_reg_classes (new_regno, reg_preferred_class (old_regno),
    5400                 :            :                                        reg_alternate_class (old_regno),
    5401                 :            :                                        reg_allocno_class (old_regno));
    5402                 :            :                 }
    5403                 :            :             }
    5404                 :            :           else
    5405                 :            :             {
    5406                 :          0 :               if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
    5407                 :          0 :                 fprintf (ira_dump_file, "Flattening IR\n");
    5408                 :          0 :               ira_flattening (max_regno_before_ira, ira_max_point_before_emit);
    5409                 :            :             }
    5410                 :            :           /* New insns were generated: add notes and recalculate live
    5411                 :            :              info.  */
    5412                 :      25420 :           df_analyze ();
    5413                 :            : 
    5414                 :            :           /* ??? Rebuild the loop tree, but why?  Does the loop tree
    5415                 :            :              change if new insns were generated?  Can that be handled
    5416                 :            :              by updating the loop tree incrementally?  */
    5417                 :      25420 :           loop_optimizer_finalize ();
    5418                 :      25420 :           free_dominance_info (CDI_DOMINATORS);
    5419                 :      25420 :           loop_optimizer_init (AVOID_CFG_MODIFICATIONS
    5420                 :            :                                | LOOPS_HAVE_RECORDED_EXITS);
    5421                 :            : 
    5422                 :      25420 :           if (! ira_use_lra_p)
    5423                 :            :             {
    5424                 :          0 :               setup_allocno_assignment_flags ();
    5425                 :          0 :               ira_initiate_assign ();
    5426                 :          0 :               ira_reassign_conflict_allocnos (max_regno);
    5427                 :            :             }
    5428                 :            :         }
    5429                 :            :     }
    5430                 :            : 
    5431                 :     944096 :   ira_finish_emit_data ();
    5432                 :            : 
    5433                 :     944096 :   setup_reg_renumber ();
    5434                 :            : 
    5435                 :     944096 :   calculate_allocation_cost ();
    5436                 :            : 
    5437                 :            : #ifdef ENABLE_IRA_CHECKING
    5438                 :     944096 :   if (ira_conflicts_p && ! ira_use_lra_p)
    5439                 :            :     /* Opposite to reload pass, LRA does not use any conflict info
    5440                 :            :        from IRA.  We don't rebuild conflict info for LRA (through
    5441                 :            :        ira_flattening call) and cannot use the check here.  We could
    5442                 :            :        rebuild this info for LRA in the check mode but there is a risk
    5443                 :            :        that code generated with the check and without it will be a bit
    5444                 :            :        different.  Calling ira_flattening in any mode would be a
    5445                 :            :        wasting CPU time.  So do not check the allocation for LRA.  */
    5446                 :          0 :     check_allocation ();
    5447                 :            : #endif
    5448                 :            : 
    5449                 :     944096 :   if (max_regno != max_regno_before_ira)
    5450                 :            :     {
    5451                 :      25030 :       regstat_free_n_sets_and_refs ();
    5452                 :      25030 :       regstat_free_ri ();
    5453                 :      25030 :       regstat_init_n_sets_and_refs ();
    5454                 :      25030 :       regstat_compute_ri ();
    5455                 :            :     }
    5456                 :            : 
    5457                 :     944096 :   overall_cost_before = ira_overall_cost;
    5458                 :     944096 :   if (! ira_conflicts_p)
    5459                 :     255548 :     grow_reg_equivs ();
    5460                 :            :   else
    5461                 :            :     {
    5462                 :     688548 :       fix_reg_equiv_init ();
    5463                 :            : 
    5464                 :            : #ifdef ENABLE_IRA_CHECKING
    5465                 :     688548 :       print_redundant_copies ();
    5466                 :            : #endif
    5467                 :     688548 :       if (! ira_use_lra_p)
    5468                 :            :         {
    5469                 :          0 :           ira_spilled_reg_stack_slots_num = 0;
    5470                 :          0 :           ira_spilled_reg_stack_slots
    5471                 :          0 :             = ((class ira_spilled_reg_stack_slot *)
    5472                 :          0 :                ira_allocate (max_regno
    5473                 :            :                              * sizeof (class ira_spilled_reg_stack_slot)));
    5474                 :          0 :           memset ((void *)ira_spilled_reg_stack_slots, 0,
    5475                 :          0 :                   max_regno * sizeof (class ira_spilled_reg_stack_slot));
    5476                 :            :         }
    5477                 :            :     }
    5478                 :     944096 :   allocate_initial_values ();
    5479                 :            : 
    5480                 :            :   /* See comment for find_moveable_pseudos call.  */
    5481                 :     944096 :   if (ira_conflicts_p)
    5482                 :     688548 :     move_unallocated_pseudos ();
    5483                 :            : 
    5484                 :            :   /* Restore original values.  */
    5485                 :     944096 :   if (lra_simple_p)
    5486                 :            :     {
    5487                 :          7 :       flag_caller_saves = saved_flag_caller_saves;
    5488                 :          7 :       flag_ira_region = saved_flag_ira_region;
    5489                 :            :     }
    5490                 :     944096 : }
    5491                 :            : 
    5492                 :            : static void
    5493                 :     944096 : do_reload (void)
    5494                 :            : {
    5495                 :     944096 :   basic_block bb;
    5496                 :     944096 :   bool need_dce;
    5497                 :     944096 :   unsigned pic_offset_table_regno = INVALID_REGNUM;
    5498                 :            : 
    5499                 :     944096 :   if (flag_ira_verbose < 10)
    5500                 :     944096 :     ira_dump_file = dump_file;
    5501                 :            : 
    5502                 :            :   /* If pic_offset_table_rtx is a pseudo register, then keep it so
    5503                 :            :      after reload to avoid possible wrong usages of hard reg assigned
    5504                 :            :      to it.  */
    5505                 :     944096 :   if (pic_offset_table_rtx
    5506                 :     944096 :       && REGNO (pic_offset_table_rtx) >= FIRST_PSEUDO_REGISTER)
    5507                 :            :     pic_offset_table_regno = REGNO (pic_offset_table_rtx);
    5508                 :            : 
    5509                 :     944096 :   timevar_push (TV_RELOAD);
    5510                 :     944096 :   if (ira_use_lra_p)
    5511                 :            :     {
    5512                 :     944096 :       if (current_loops != NULL)
    5513                 :            :         {
    5514                 :     660335 :           loop_optimizer_finalize ();
    5515                 :     660335 :           free_dominance_info (CDI_DOMINATORS);
    5516                 :            :         }
    5517                 :   11954200 :       FOR_ALL_BB_FN (bb, cfun)
    5518                 :   11010100 :         bb->loop_father = NULL;
    5519                 :     944096 :       current_loops = NULL;
    5520                 :            : 
    5521                 :     944096 :       ira_destroy ();
    5522                 :            : 
    5523                 :     944096 :       lra (ira_dump_file);
    5524                 :            :       /* ???!!! Move it before lra () when we use ira_reg_equiv in
    5525                 :            :          LRA.  */
    5526                 :     944096 :       vec_free (reg_equivs);
    5527                 :     944096 :       reg_equivs = NULL;
    5528                 :     944096 :       need_dce = false;
    5529                 :            :     }
    5530                 :            :   else
    5531                 :            :     {
    5532                 :          0 :       df_set_flags (DF_NO_INSN_RESCAN);
    5533                 :          0 :       build_insn_chain ();
    5534                 :            : 
    5535                 :          0 :       need_dce = reload (get_insns (), ira_conflicts_p);
    5536                 :            :     }
    5537                 :            : 
    5538                 :     944096 :   timevar_pop (TV_RELOAD);
    5539                 :            : 
    5540                 :     944096 :   timevar_push (TV_IRA);
    5541                 :            : 
    5542                 :     944096 :   if (ira_conflicts_p && ! ira_use_lra_p)
    5543                 :            :     {
    5544                 :          0 :       ira_free (ira_spilled_reg_stack_slots);
    5545                 :          0 :       ira_finish_assign ();
    5546                 :            :     }
    5547                 :            : 
    5548                 :     944096 :   if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL
    5549                 :        109 :       && overall_cost_before != ira_overall_cost)
    5550                 :          0 :     fprintf (ira_dump_file, "+++Overall after reload %" PRId64 "\n",
    5551                 :            :              ira_overall_cost);
    5552                 :            : 
    5553                 :     944096 :   flag_ira_share_spill_slots = saved_flag_ira_share_spill_slots;
    5554                 :            : 
    5555                 :     944096 :   if (! ira_use_lra_p)
    5556                 :            :     {
    5557                 :          0 :       ira_destroy ();
    5558                 :          0 :       if (current_loops != NULL)
    5559                 :            :         {
    5560                 :          0 :           loop_optimizer_finalize ();
    5561                 :          0 :           free_dominance_info (CDI_DOMINATORS);
    5562                 :            :         }
    5563                 :          0 :       FOR_ALL_BB_FN (bb, cfun)
    5564                 :          0 :         bb->loop_father = NULL;
    5565                 :          0 :       current_loops = NULL;
    5566                 :            :       
    5567                 :          0 :       regstat_free_ri ();
    5568                 :          0 :       regstat_free_n_sets_and_refs ();
    5569                 :            :     }
    5570                 :            : 
    5571                 :     944096 :   if (optimize)
    5572                 :     688548 :     cleanup_cfg (CLEANUP_EXPENSIVE);
    5573                 :            : 
    5574                 :     944096 :   finish_reg_equiv ();
    5575                 :            : 
    5576                 :     944096 :   bitmap_obstack_release (&ira_bitmap_obstack);
    5577                 :            : #ifndef IRA_NO_OBSTACK
    5578                 :            :   obstack_free (&ira_obstack, NULL);
    5579                 :            : #endif
    5580                 :            : 
    5581                 :            :   /* The code after the reload has changed so much that at this point
    5582                 :            :      we might as well just rescan everything.  Note that
    5583                 :            :      df_rescan_all_insns is not going to help here because it does not
    5584                 :            :      touch the artificial uses and defs.  */
    5585                 :     944096 :   df_finish_pass (true);
    5586                 :     944096 :   df_scan_alloc (NULL);
    5587                 :     944096 :   df_scan_blocks ();
    5588                 :            : 
    5589                 :     944096 :   if (optimize > 1)
    5590                 :            :     {
    5591                 :     645364 :       df_live_add_problem ();
    5592                 :     645364 :       df_live_set_all_dirty ();
    5593                 :            :     }
    5594                 :            : 
    5595                 :     944096 :   if (optimize)
    5596                 :     688548 :     df_analyze ();
    5597                 :            : 
    5598                 :     944096 :   if (need_dce && optimize)
    5599                 :          0 :     run_fast_dce ();
    5600                 :            : 
    5601                 :            :   /* Diagnose uses of the hard frame pointer when it is used as a global
    5602                 :            :      register.  Often we can get away with letting the user appropriate
    5603                 :            :      the frame pointer, but we should let them know when code generation
    5604                 :            :      makes that impossible.  */
    5605                 :     944096 :   if (global_regs[HARD_FRAME_POINTER_REGNUM] && frame_pointer_needed)
    5606                 :            :     {
    5607                 :          2 :       tree decl = global_regs_decl[HARD_FRAME_POINTER_REGNUM];
    5608                 :          2 :       error_at (DECL_SOURCE_LOCATION (current_function_decl),
    5609                 :            :                 "frame pointer required, but reserved");
    5610                 :          2 :       inform (DECL_SOURCE_LOCATION (decl), "for %qD", decl);
    5611                 :            :     }
    5612                 :            : 
    5613                 :            :   /* If we are doing generic stack checking, give a warning if this
    5614                 :            :      function's frame size is larger than we expect.  */
    5615                 :     944096 :   if (flag_stack_check == GENERIC_STACK_CHECK)
    5616                 :            :     {
    5617                 :          8 :       poly_int64 size = get_frame_size () + STACK_CHECK_FIXED_FRAME_SIZE;
    5618                 :            : 
    5619                 :        616 :       for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    5620                 :        608 :         if (df_regs_ever_live_p (i)
    5621                 :         25 :             && !fixed_regs[i]
    5622                 :        629 :             && !crtl->abi->clobbers_full_reg_p (i))
    5623                 :          6 :           size += UNITS_PER_WORD;
    5624                 :            : 
    5625                 :          8 :       if (constant_lower_bound (size) > STACK_CHECK_MAX_FRAME_SIZE)
    5626                 :          1 :         warning (0, "frame size too large for reliable stack checking");
    5627                 :            :     }
    5628                 :            : 
    5629                 :     944096 :   if (pic_offset_table_regno != INVALID_REGNUM)
    5630                 :      61535 :     pic_offset_table_rtx = gen_rtx_REG (Pmode, pic_offset_table_regno);
    5631                 :            : 
    5632                 :     944096 :   timevar_pop (TV_IRA);
    5633                 :     944096 : }
    5634                 :            : 
    5635                 :            : /* Run the integrated register allocator.  */
    5636                 :            : 
    5637                 :            : namespace {
    5638                 :            : 
    5639                 :            : const pass_data pass_data_ira =
    5640                 :            : {
    5641                 :            :   RTL_PASS, /* type */
    5642                 :            :   "ira", /* name */
    5643                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5644                 :            :   TV_IRA, /* tv_id */
    5645                 :            :   0, /* properties_required */
    5646                 :            :   0, /* properties_provided */
    5647                 :            :   0, /* properties_destroyed */
    5648                 :            :   0, /* todo_flags_start */
    5649                 :            :   TODO_do_not_ggc_collect, /* todo_flags_finish */
    5650                 :            : };
    5651                 :            : 
    5652                 :            : class pass_ira : public rtl_opt_pass
    5653                 :            : {
    5654                 :            : public:
    5655                 :     200773 :   pass_ira (gcc::context *ctxt)
    5656                 :     401546 :     : rtl_opt_pass (pass_data_ira, ctxt)
    5657                 :            :   {}
    5658                 :            : 
    5659                 :            :   /* opt_pass methods: */
    5660                 :     944101 :   virtual bool gate (function *)
    5661                 :            :     {
    5662                 :     944101 :       return !targetm.no_register_allocation;
    5663                 :            :     }
    5664                 :     944096 :   virtual unsigned int execute (function *)
    5665                 :            :     {
    5666                 :     944096 :       ira (dump_file);
    5667                 :     944096 :       return 0;
    5668                 :            :     }
    5669                 :            : 
    5670                 :            : }; // class pass_ira
    5671                 :            : 
    5672                 :            : } // anon namespace
    5673                 :            : 
    5674                 :            : rtl_opt_pass *
    5675                 :     200773 : make_pass_ira (gcc::context *ctxt)
    5676                 :            : {
    5677                 :     200773 :   return new pass_ira (ctxt);
    5678                 :            : }
    5679                 :            : 
    5680                 :            : namespace {
    5681                 :            : 
    5682                 :            : const pass_data pass_data_reload =
    5683                 :            : {
    5684                 :            :   RTL_PASS, /* type */
    5685                 :            :   "reload", /* name */
    5686                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5687                 :            :   TV_RELOAD, /* tv_id */
    5688                 :            :   0, /* properties_required */
    5689                 :            :   0, /* properties_provided */
    5690                 :            :   0, /* properties_destroyed */
    5691                 :            :   0, /* todo_flags_start */
    5692                 :            :   0, /* todo_flags_finish */
    5693                 :            : };
    5694                 :            : 
    5695                 :            : class pass_reload : public rtl_opt_pass
    5696                 :            : {
    5697                 :            : public:
    5698                 :     200773 :   pass_reload (gcc::context *ctxt)
    5699                 :     401546 :     : rtl_opt_pass (pass_data_reload, ctxt)
    5700                 :            :   {}
    5701                 :            : 
    5702                 :            :   /* opt_pass methods: */
    5703                 :     944101 :   virtual bool gate (function *)
    5704                 :            :     {
    5705                 :     944101 :       return !targetm.no_register_allocation;
    5706                 :            :     }
    5707                 :     944096 :   virtual unsigned int execute (function *)
    5708                 :            :     {
    5709                 :     944096 :       do_reload ();
    5710                 :     944096 :       return 0;
    5711                 :            :     }
    5712                 :            : 
    5713                 :            : }; // class pass_reload
    5714                 :            : 
    5715                 :            : } // anon namespace
    5716                 :            : 
    5717                 :            : rtl_opt_pass *
    5718                 :     200773 : make_pass_reload (gcc::context *ctxt)
    5719                 :            : {
    5720                 :     200773 :   return new pass_reload (ctxt);
    5721                 :            : }

Generated by: LCOV version 1.0

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