gcc/lra-coalesce.c

   1 /* Coalesce spilled pseudos.
   2    Copyright (C) 2010-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
  22 /* This file contains a pass making some simple RTL code
  23    transformations by coalescing pseudos to remove some move insns.
  24
  25    Spilling pseudos in LRA can create memory-memory moves.  We should
  26    remove potential memory-memory moves before the next constraint
  27    pass because the constraint pass will generate additional insns for
  28    such moves and all these insns will be hard to remove afterwards.
  29
  30    Here we coalesce only spilled pseudos.  Coalescing non-spilled
  31    pseudos (with different hard regs) might result in spilling
  32    additional pseudos because of possible conflicts with other
  33    non-spilled pseudos and, as a consequence, in more constraint
  34    passes and even LRA infinite cycling.  Trivial the same hard
  35    register moves will be removed by subsequent compiler passes.
  36
  37    We don't coalesce special reload pseudos.  It complicates LRA code
  38    a lot without visible generated code improvement.
  39
  40    The pseudo live-ranges are used to find conflicting pseudos during
  41    coalescing.
  42
  43    Most frequently executed moves is tried to be coalesced first.  */
  44
  45 #include "config.h"
  46 #include "system.h"
  47 #include "coretypes.h"
  48 #include "backend.h"
  49 #include "rtl.h"
  50 #include "predict.h"
  51 #include "df.h"
  52 #include "insn-config.h"
  53 #include "regs.h"
  54 #include "memmodel.h"
  55 #include "ira.h"
  56 #include "recog.h"
  57 #include "lra-int.h"
  58
  59 /* Arrays whose elements represent the first and the next pseudo
  60    (regno) in the coalesced pseudos group to which given pseudo (its
  61    regno is the index) belongs.  The next of the last pseudo in the
  62    group refers to the first pseudo in the group, in other words the
  63    group is represented by a cyclic list.  */
  64 static int *first_coalesced_pseudo, *next_coalesced_pseudo;
  65
  66 /* The function is used to sort moves according to their execution
  67    frequencies.  */
  68 static int
  69 move_freq_compare_func (const void *v1p, const void *v2p)
  70 {
  71   rtx_insn *mv1 = *(rtx_insn * const *) v1p;
  72   rtx_insn *mv2 = *(rtx_insn * const *) v2p;
  73   int pri1, pri2;
  74
  75   pri1 = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (mv1));
  76   pri2 = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (mv2));
  77   if (pri2 - pri1)
  78     return pri2 - pri1;
  79
  80   /* If frequencies are equal, sort by moves, so that the results of
  81      qsort leave nothing to chance.  */
  82   return (int) INSN_UID (mv1) - (int) INSN_UID (mv2);
  83 }
  84
  85 /* Pseudos which go away after coalescing.  */
  86 static bitmap_head coalesced_pseudos_bitmap;
  87
  88 /* Merge two sets of coalesced pseudos given correspondingly by
  89    pseudos REGNO1 and REGNO2 (more accurately merging REGNO2 group
  90    into REGNO1 group).  Set up COALESCED_PSEUDOS_BITMAP.  */
  91 static void
  92 merge_pseudos (int regno1, int regno2)
  93 {
  94   int regno, first, first2, last, next;
  95
  96   first = first_coalesced_pseudo[regno1];
  97   if ((first2 = first_coalesced_pseudo[regno2]) == first)
  98     return;
  99   for (last = regno2, regno = next_coalesced_pseudo[regno2];;
 100        regno = next_coalesced_pseudo[regno])
 101     {
 102       first_coalesced_pseudo[regno] = first;
 103       bitmap_set_bit (&coalesced_pseudos_bitmap, regno);
 104       if (regno == regno2)
 105         break;
 106       last = regno;
 107     }
 108   next = next_coalesced_pseudo[first];
 109   next_coalesced_pseudo[first] = regno2;
 110   next_coalesced_pseudo[last] = next;
 111   lra_reg_info[first].live_ranges
 112     = (lra_merge_live_ranges
 113        (lra_reg_info[first].live_ranges,
 114         lra_copy_live_range_list (lra_reg_info[first2].live_ranges)));
 115   if (partial_subreg_p (lra_reg_info[first].biggest_mode,
 116                         lra_reg_info[first2].biggest_mode))
 117     lra_reg_info[first].biggest_mode = lra_reg_info[first2].biggest_mode;
 118 }
 119
 120 /* Change pseudos in *LOC on their coalescing group
 121    representatives.  */
 122 static bool
 123 substitute (rtx *loc)
 124 {
 125   int i, regno;
 126   const char *fmt;
 127   enum rtx_code code;
 128   bool res;
 129
 130   if (*loc == NULL_RTX)
 131     return false;
 132   code = GET_CODE (*loc);
 133   if (code == REG)
 134     {
 135       regno = REGNO (*loc);
 136       if (regno < FIRST_PSEUDO_REGISTER
 137           || first_coalesced_pseudo[regno] == regno)
 138         return false;
 139       *loc = regno_reg_rtx[first_coalesced_pseudo[regno]];
 140       return true;
 141     }
 142
 143   res = false;
 144   fmt = GET_RTX_FORMAT (code);
 145   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 146     {
 147       if (fmt[i] == 'e')
 148         {
 149           if (substitute (&XEXP (*loc, i)))
 150             res = true;
 151         }
 152       else if (fmt[i] == 'E')
 153         {
 154           int j;
 155
 156           for (j = XVECLEN (*loc, i) - 1; j >= 0; j--)
 157             if (substitute (&XVECEXP (*loc, i, j)))
 158               res = true;
 159         }
 160     }
 161   return res;
 162 }
 163
 164 /* Specialize "substitute" for use on an insn.  This can't change
 165    the insn ptr, just the contents of the insn.  */
 166
 167 static bool
 168 substitute_within_insn (rtx_insn *insn)
 169 {
 170   rtx loc = insn;
 171   return substitute (&loc);
 172 }
 173
 174 /* The current iteration (1, 2, ...) of the coalescing pass.  */
 175 int lra_coalesce_iter;
 176
 177 /* Return true if the move involving REGNO1 and REGNO2 is a potential
 178    memory-memory move.  */
 179 static bool
 180 mem_move_p (int regno1, int regno2)
 181 {
 182   return reg_renumber[regno1] < 0 && reg_renumber[regno2] < 0;
 183 }
 184
 185 /* Pseudos used instead of the coalesced pseudos.  */
 186 static bitmap_head used_pseudos_bitmap;
 187
 188 /* Set up USED_PSEUDOS_BITMAP, and update LR_BITMAP (a BB live info
 189    bitmap).  */
 190 static void
 191 update_live_info (bitmap lr_bitmap)
 192 {
 193   unsigned int j;
 194   bitmap_iterator bi;
 195
 196   bitmap_clear (&used_pseudos_bitmap);
 197   EXECUTE_IF_AND_IN_BITMAP (&coalesced_pseudos_bitmap, lr_bitmap,
 198                             FIRST_PSEUDO_REGISTER, j, bi)
 199     bitmap_set_bit (&used_pseudos_bitmap, first_coalesced_pseudo[j]);
 200   if (! bitmap_empty_p (&used_pseudos_bitmap))
 201     {
 202       bitmap_and_compl_into (lr_bitmap, &coalesced_pseudos_bitmap);
 203       bitmap_ior_into (lr_bitmap, &used_pseudos_bitmap);
 204     }
 205 }
 206
 207 /* Return true if pseudo REGNO can be potentially coalesced.  */
 208 static bool
 209 coalescable_pseudo_p (int regno)
 210 {
 211   lra_assert (regno >= FIRST_PSEUDO_REGISTER);
 212   return (/* We don't want to coalesce regnos with equivalences, at
 213              least without updating this info.  */
 214           ira_reg_equiv[regno].constant == NULL_RTX
 215           && ira_reg_equiv[regno].memory == NULL_RTX
 216           && ira_reg_equiv[regno].invariant == NULL_RTX);
 217 }
 218
 219 /* The major function for aggressive pseudo coalescing of moves only
 220    if the both pseudos were spilled and not special reload pseudos.  */
 221 bool
 222 lra_coalesce (void)
 223 {
 224   basic_block bb;
 225   rtx_insn *mv, *insn, *next, **sorted_moves;
 226   rtx set;
 227   int i, mv_num, sregno, dregno;
 228   int coalesced_moves;
 229   int max_regno = max_reg_num ();
 230   bitmap_head involved_insns_bitmap;
 231
 232   timevar_push (TV_LRA_COALESCE);
 233
 234   if (lra_dump_file != NULL)
 235     fprintf (lra_dump_file,
 236              "\n********** Pseudos coalescing #%d: **********\n\n",
 237              ++lra_coalesce_iter);
 238   first_coalesced_pseudo = XNEWVEC (int, max_regno);
 239   next_coalesced_pseudo = XNEWVEC (int, max_regno);
 240   for (i = 0; i < max_regno; i++)
 241     first_coalesced_pseudo[i] = next_coalesced_pseudo[i] = i;
 242   sorted_moves = XNEWVEC (rtx_insn *, get_max_uid ());
 243   mv_num = 0;
 244   /* Collect moves.  */
 245   coalesced_moves = 0;
 246   FOR_EACH_BB_FN (bb, cfun)
 247     {
 248       FOR_BB_INSNS_SAFE (bb, insn, next)
 249         if (INSN_P (insn)
 250             && (set = single_set (insn)) != NULL_RTX
 251             && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set))
 252             && (sregno = REGNO (SET_SRC (set))) >= FIRST_PSEUDO_REGISTER
 253             && (dregno = REGNO (SET_DEST (set))) >= FIRST_PSEUDO_REGISTER
 254             && mem_move_p (sregno, dregno)
 255             && coalescable_pseudo_p (sregno) && coalescable_pseudo_p (dregno)
 256             && ! side_effects_p (set)
 257             && !(lra_intersected_live_ranges_p
 258                  (lra_reg_info[sregno].live_ranges,
 259                   lra_reg_info[dregno].live_ranges)))
 260           sorted_moves[mv_num++] = insn;
 261     }
 262   qsort (sorted_moves, mv_num, sizeof (rtx), move_freq_compare_func);
 263   /* Coalesced copies, most frequently executed first.  */
 264   bitmap_initialize (&coalesced_pseudos_bitmap, &reg_obstack);
 265   bitmap_initialize (&involved_insns_bitmap, &reg_obstack);
 266   for (i = 0; i < mv_num; i++)
 267     {
 268       mv = sorted_moves[i];
 269       set = single_set (mv);
 270       lra_assert (set != NULL && REG_P (SET_SRC (set))
 271                   && REG_P (SET_DEST (set)));
 272       sregno = REGNO (SET_SRC (set));
 273       dregno = REGNO (SET_DEST (set));
 274       if (first_coalesced_pseudo[sregno] == first_coalesced_pseudo[dregno])
 275         {
 276           coalesced_moves++;
 277           if (lra_dump_file != NULL)
 278             fprintf
 279               (lra_dump_file, "      Coalescing move %i:r%d-r%d (freq=%d)\n",
 280                INSN_UID (mv), sregno, dregno,
 281                REG_FREQ_FROM_BB (BLOCK_FOR_INSN (mv)));
 282           /* We updated involved_insns_bitmap when doing the merge.  */
 283         }
 284       else if (!(lra_intersected_live_ranges_p
 285                  (lra_reg_info[first_coalesced_pseudo[sregno]].live_ranges,
 286                   lra_reg_info[first_coalesced_pseudo[dregno]].live_ranges)))
 287         {
 288           coalesced_moves++;
 289           if (lra_dump_file != NULL)
 290             fprintf
 291               (lra_dump_file,
 292                "  Coalescing move %i:r%d(%d)-r%d(%d) (freq=%d)\n",
 293                INSN_UID (mv), sregno, ORIGINAL_REGNO (SET_SRC (set)),
 294                dregno, ORIGINAL_REGNO (SET_DEST (set)),
 295                REG_FREQ_FROM_BB (BLOCK_FOR_INSN (mv)));
 296           bitmap_ior_into (&involved_insns_bitmap,
 297                            &lra_reg_info[sregno].insn_bitmap);
 298           bitmap_ior_into (&involved_insns_bitmap,
 299                            &lra_reg_info[dregno].insn_bitmap);
 300           merge_pseudos (sregno, dregno);
 301         }
 302     }
 303   bitmap_initialize (&used_pseudos_bitmap, &reg_obstack);
 304   FOR_EACH_BB_FN (bb, cfun)
 305     {
 306       update_live_info (df_get_live_in (bb));
 307       update_live_info (df_get_live_out (bb));
 308       FOR_BB_INSNS_SAFE (bb, insn, next)
 309         if (INSN_P (insn)
 310             && bitmap_bit_p (&involved_insns_bitmap, INSN_UID (insn)))
 311           {
 312             if (! substitute_within_insn (insn))
 313               continue;
 314             lra_update_insn_regno_info (insn);
 315             if ((set = single_set (insn)) != NULL_RTX && set_noop_p (set))
 316               {
 317                 /* Coalesced move.  */
 318                 if (lra_dump_file != NULL)
 319                   fprintf (lra_dump_file, "      Removing move %i (freq=%d)\n",
 320                            INSN_UID (insn),
 321                            REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn)));
 322                 lra_set_insn_deleted (insn);
 323               }
 324           }
 325     }
 326   /* If we have situation after inheritance pass:
 327
 328      r1 <- p1   insn originally setting p1
 329      i1 <- r1   setting inheritance i1 from reload r1
 330        ...
 331      ... <- ... p2 ... dead p2
 332      ..
 333      p1 <- i1
 334      r2 <- i1
 335      ...<- ... r2 ...
 336
 337      And we are coalescing p1 and p2 using p1.  In this case i1 and p1
 338      should have different values, otherwise they can get the same
 339      hard reg and this is wrong for insn using p2 before coalescing.
 340      The situation even can be more complicated when new reload
 341      pseudos occur after the inheriatnce.  So invalidate the result
 342      pseudos.  */
 343   for (i = 0; i < max_regno; i++)
 344     if (first_coalesced_pseudo[i] == i
 345         && first_coalesced_pseudo[i] != next_coalesced_pseudo[i])
 346       {
 347         lra_set_regno_unique_value (i);
 348         if (lra_dump_file != NULL)
 349           fprintf (lra_dump_file,
 350                    "     Make unique value for coalescing result r%d\n", i);
 351       }
 352   bitmap_clear (&used_pseudos_bitmap);
 353   bitmap_clear (&involved_insns_bitmap);
 354   bitmap_clear (&coalesced_pseudos_bitmap);
 355   if (lra_dump_file != NULL && coalesced_moves != 0)
 356     fprintf (lra_dump_file, "Coalesced Moves = %d\n", coalesced_moves);
 357   free (sorted_moves);
 358   free (next_coalesced_pseudo);
 359   free (first_coalesced_pseudo);
 360   timevar_pop (TV_LRA_COALESCE);
 361   return coalesced_moves != 0;
 362 }