gcc/regcprop.c

   1 /* Copy propagation on hard registers for the GNU compiler.
   2    Copyright (C) 2000-2015 Free Software Foundation, Inc.
   3
   4    This file is part of GCC.
   5
   6    GCC is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GCC is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GCC; see the file COPYING3.  If not see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "backend.h"
  24 #include "rtl.h"
  25 #include "df.h"
  26 #include "tm_p.h"
  27 #include "insn-config.h"
  28 #include "regs.h"
  29 #include "addresses.h"
  30 #include "reload.h"
  31 #include "recog.h"
  32 #include "flags.h"
  33 #include "diagnostic-core.h"
  34 #include "tree-pass.h"
  35 #include "rtl-iter.h"
  36 #include "emit-rtl.h"
  37
  38 /* The following code does forward propagation of hard register copies.
  39    The object is to eliminate as many dependencies as possible, so that
  40    we have the most scheduling freedom.  As a side effect, we also clean
  41    up some silly register allocation decisions made by reload.  This
  42    code may be obsoleted by a new register allocator.  */
  43
  44 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
  45    lifetime of a register and get the DEBUG_INSN subsequently reset.
  46    So they are queued instead, and updated only when the register is
  47    used in some subsequent real insn before it is set.  */
  48 struct queued_debug_insn_change
  49 {
  50   struct queued_debug_insn_change *next;
  51   rtx_insn *insn;
  52   rtx *loc;
  53   rtx new_rtx;
  54 };
  55
  56 /* For each register, we have a list of registers that contain the same
  57    value.  The OLDEST_REGNO field points to the head of the list, and
  58    the NEXT_REGNO field runs through the list.  The MODE field indicates
  59    what mode the data is known to be in; this field is VOIDmode when the
  60    register is not known to contain valid data.  */
  61
  62 struct value_data_entry
  63 {
  64   machine_mode mode;
  65   unsigned int oldest_regno;
  66   unsigned int next_regno;
  67   struct queued_debug_insn_change *debug_insn_changes;
  68 };
  69
  70 struct value_data
  71 {
  72   struct value_data_entry e[FIRST_PSEUDO_REGISTER];
  73   unsigned int max_value_regs;
  74   unsigned int n_debug_insn_changes;
  75 };
  76
  77 static object_allocator<queued_debug_insn_change> queued_debug_insn_change_pool
  78   ("debug insn changes pool", 256);
  79
  80 static bool skip_debug_insn_p;
  81
  82 static void kill_value_one_regno (unsigned, struct value_data *);
  83 static void kill_value_regno (unsigned, unsigned, struct value_data *);
  84 static void kill_value (const_rtx, struct value_data *);
  85 static void set_value_regno (unsigned, machine_mode, struct value_data *);
  86 static void init_value_data (struct value_data *);
  87 static void kill_clobbered_value (rtx, const_rtx, void *);
  88 static void kill_set_value (rtx, const_rtx, void *);
  89 static void copy_value (rtx, rtx, struct value_data *);
  90 static bool mode_change_ok (machine_mode, machine_mode,
  91                             unsigned int);
  92 static rtx maybe_mode_change (machine_mode, machine_mode,
  93                               machine_mode, unsigned int, unsigned int);
  94 static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
  95 static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx_insn *,
  96                                       struct value_data *);
  97 static bool replace_oldest_value_addr (rtx *, enum reg_class,
  98                                        machine_mode, addr_space_t,
  99                                        rtx_insn *, struct value_data *);
 100 static bool replace_oldest_value_mem (rtx, rtx_insn *, struct value_data *);
 101 static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
 102 extern void debug_value_data (struct value_data *);
 103 #ifdef ENABLE_CHECKING
 104 static void validate_value_data (struct value_data *);
 105 #endif
 106
 107 /* Free all queued updates for DEBUG_INSNs that change some reg to
 108    register REGNO.  */
 109
 110 static void
 111 free_debug_insn_changes (struct value_data *vd, unsigned int regno)
 112 {
 113   struct queued_debug_insn_change *cur, *next;
 114   for (cur = vd->e[regno].debug_insn_changes; cur; cur = next)
 115     {
 116       next = cur->next;
 117       --vd->n_debug_insn_changes;
 118       queued_debug_insn_change_pool.remove (cur);
 119     }
 120   vd->e[regno].debug_insn_changes = NULL;
 121 }
 122
 123 /* Kill register REGNO.  This involves removing it from any value
 124    lists, and resetting the value mode to VOIDmode.  This is only a
 125    helper function; it does not handle any hard registers overlapping
 126    with REGNO.  */
 127
 128 static void
 129 kill_value_one_regno (unsigned int regno, struct value_data *vd)
 130 {
 131   unsigned int i, next;
 132
 133   if (vd->e[regno].oldest_regno != regno)
 134     {
 135       for (i = vd->e[regno].oldest_regno;
 136            vd->e[i].next_regno != regno;
 137            i = vd->e[i].next_regno)
 138         continue;
 139       vd->e[i].next_regno = vd->e[regno].next_regno;
 140     }
 141   else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
 142     {
 143       for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
 144         vd->e[i].oldest_regno = next;
 145     }
 146
 147   vd->e[regno].mode = VOIDmode;
 148   vd->e[regno].oldest_regno = regno;
 149   vd->e[regno].next_regno = INVALID_REGNUM;
 150   if (vd->e[regno].debug_insn_changes)
 151     free_debug_insn_changes (vd, regno);
 152
 153 #ifdef ENABLE_CHECKING
 154   validate_value_data (vd);
 155 #endif
 156 }
 157
 158 /* Kill the value in register REGNO for NREGS, and any other registers
 159    whose values overlap.  */
 160
 161 static void
 162 kill_value_regno (unsigned int regno, unsigned int nregs,
 163                   struct value_data *vd)
 164 {
 165   unsigned int j;
 166
 167   /* Kill the value we're told to kill.  */
 168   for (j = 0; j < nregs; ++j)
 169     kill_value_one_regno (regno + j, vd);
 170
 171   /* Kill everything that overlapped what we're told to kill.  */
 172   if (regno < vd->max_value_regs)
 173     j = 0;
 174   else
 175     j = regno - vd->max_value_regs;
 176   for (; j < regno; ++j)
 177     {
 178       unsigned int i, n;
 179       if (vd->e[j].mode == VOIDmode)
 180         continue;
 181       n = hard_regno_nregs[j][vd->e[j].mode];
 182       if (j + n > regno)
 183         for (i = 0; i < n; ++i)
 184           kill_value_one_regno (j + i, vd);
 185     }
 186 }
 187
 188 /* Kill X.  This is a convenience function wrapping kill_value_regno
 189    so that we mind the mode the register is in.  */
 190
 191 static void
 192 kill_value (const_rtx x, struct value_data *vd)
 193 {
 194   if (GET_CODE (x) == SUBREG)
 195     {
 196       rtx tmp = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
 197                                  GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
 198       x = tmp ? tmp : SUBREG_REG (x);
 199     }
 200   if (REG_P (x))
 201     kill_value_regno (REGNO (x), REG_NREGS (x), vd);
 202 }
 203
 204 /* Remember that REGNO is valid in MODE.  */
 205
 206 static void
 207 set_value_regno (unsigned int regno, machine_mode mode,
 208                  struct value_data *vd)
 209 {
 210   unsigned int nregs;
 211
 212   vd->e[regno].mode = mode;
 213
 214   nregs = hard_regno_nregs[regno][mode];
 215   if (nregs > vd->max_value_regs)
 216     vd->max_value_regs = nregs;
 217 }
 218
 219 /* Initialize VD such that there are no known relationships between regs.  */
 220
 221 static void
 222 init_value_data (struct value_data *vd)
 223 {
 224   int i;
 225   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
 226     {
 227       vd->e[i].mode = VOIDmode;
 228       vd->e[i].oldest_regno = i;
 229       vd->e[i].next_regno = INVALID_REGNUM;
 230       vd->e[i].debug_insn_changes = NULL;
 231     }
 232   vd->max_value_regs = 0;
 233   vd->n_debug_insn_changes = 0;
 234 }
 235
 236 /* Called through note_stores.  If X is clobbered, kill its value.  */
 237
 238 static void
 239 kill_clobbered_value (rtx x, const_rtx set, void *data)
 240 {
 241   struct value_data *const vd = (struct value_data *) data;
 242   if (GET_CODE (set) == CLOBBER)
 243     kill_value (x, vd);
 244 }
 245
 246 /* A structure passed as data to kill_set_value through note_stores.  */
 247 struct kill_set_value_data
 248 {
 249   struct value_data *vd;
 250   rtx ignore_set_reg;
 251 };
 252
 253 /* Called through note_stores.  If X is set, not clobbered, kill its
 254    current value and install it as the root of its own value list.  */
 255
 256 static void
 257 kill_set_value (rtx x, const_rtx set, void *data)
 258 {
 259   struct kill_set_value_data *ksvd = (struct kill_set_value_data *) data;
 260   if (rtx_equal_p (x, ksvd->ignore_set_reg))
 261     return;
 262   if (GET_CODE (set) != CLOBBER)
 263     {
 264       kill_value (x, ksvd->vd);
 265       if (REG_P (x))
 266         set_value_regno (REGNO (x), GET_MODE (x), ksvd->vd);
 267     }
 268 }
 269
 270 /* Kill any register used in X as the base of an auto-increment expression,
 271    and install that register as the root of its own value list.  */
 272
 273 static void
 274 kill_autoinc_value (rtx_insn *insn, struct value_data *vd)
 275 {
 276   subrtx_iterator::array_type array;
 277   FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
 278     {
 279       const_rtx x = *iter;
 280       if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
 281         {
 282           x = XEXP (x, 0);
 283           kill_value (x, vd);
 284           set_value_regno (REGNO (x), GET_MODE (x), vd);
 285           iter.skip_subrtxes ();
 286         }
 287     }
 288 }
 289
 290 /* Assert that SRC has been copied to DEST.  Adjust the data structures
 291    to reflect that SRC contains an older copy of the shared value.  */
 292
 293 static void
 294 copy_value (rtx dest, rtx src, struct value_data *vd)
 295 {
 296   unsigned int dr = REGNO (dest);
 297   unsigned int sr = REGNO (src);
 298   unsigned int dn, sn;
 299   unsigned int i;
 300
 301   /* ??? At present, it's possible to see noop sets.  It'd be nice if
 302      this were cleaned up beforehand...  */
 303   if (sr == dr)
 304     return;
 305
 306   /* Do not propagate copies to the stack pointer, as that can leave
 307      memory accesses with no scheduling dependency on the stack update.  */
 308   if (dr == STACK_POINTER_REGNUM)
 309     return;
 310
 311   /* Likewise with the frame pointer, if we're using one.  */
 312   if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
 313     return;
 314
 315   /* Do not propagate copies to fixed or global registers, patterns
 316      can be relying to see particular fixed register or users can
 317      expect the chosen global register in asm.  */
 318   if (fixed_regs[dr] || global_regs[dr])
 319     return;
 320
 321   /* If SRC and DEST overlap, don't record anything.  */
 322   dn = REG_NREGS (dest);
 323   sn = REG_NREGS (src);
 324   if ((dr > sr && dr < sr + sn)
 325       || (sr > dr && sr < dr + dn))
 326     return;
 327
 328   /* If SRC had no assigned mode (i.e. we didn't know it was live)
 329      assign it now and assume the value came from an input argument
 330      or somesuch.  */
 331   if (vd->e[sr].mode == VOIDmode)
 332     set_value_regno (sr, vd->e[dr].mode, vd);
 333
 334   /* If we are narrowing the input to a smaller number of hard regs,
 335      and it is in big endian, we are really extracting a high part.
 336      Since we generally associate a low part of a value with the value itself,
 337      we must not do the same for the high part.
 338      Note we can still get low parts for the same mode combination through
 339      a two-step copy involving differently sized hard regs.
 340      Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
 341      (set (reg:DI r0) (reg:DI fr0))
 342      (set (reg:SI fr2) (reg:SI r0))
 343      loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
 344      (set (reg:SI fr2) (reg:SI fr0))
 345      loads the high part of (reg:DI fr0) into fr2.
 346
 347      We can't properly represent the latter case in our tables, so don't
 348      record anything then.  */
 349   else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]
 350            && (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
 351                ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
 352     return;
 353
 354   /* If SRC had been assigned a mode narrower than the copy, we can't
 355      link DEST into the chain, because not all of the pieces of the
 356      copy came from oldest_regno.  */
 357   else if (sn > (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode])
 358     return;
 359
 360   /* Link DR at the end of the value chain used by SR.  */
 361
 362   vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
 363
 364   for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
 365     continue;
 366   vd->e[i].next_regno = dr;
 367
 368 #ifdef ENABLE_CHECKING
 369   validate_value_data (vd);
 370 #endif
 371 }
 372
 373 /* Return true if a mode change from ORIG to NEW is allowed for REGNO.  */
 374
 375 static bool
 376 mode_change_ok (machine_mode orig_mode, machine_mode new_mode,
 377                 unsigned int regno ATTRIBUTE_UNUSED)
 378 {
 379   if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode))
 380     return false;
 381
 382 #ifdef CANNOT_CHANGE_MODE_CLASS
 383   return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode);
 384 #endif
 385
 386   return true;
 387 }
 388
 389 /* Register REGNO was originally set in ORIG_MODE.  It - or a copy of it -
 390    was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
 391    in NEW_MODE.
 392    Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX.  */
 393
 394 static rtx
 395 maybe_mode_change (machine_mode orig_mode, machine_mode copy_mode,
 396                    machine_mode new_mode, unsigned int regno,
 397                    unsigned int copy_regno ATTRIBUTE_UNUSED)
 398 {
 399   if (GET_MODE_SIZE (copy_mode) < GET_MODE_SIZE (orig_mode)
 400       && GET_MODE_SIZE (copy_mode) < GET_MODE_SIZE (new_mode))
 401     return NULL_RTX;
 402
 403   if (orig_mode == new_mode)
 404     return gen_raw_REG (new_mode, regno);
 405   else if (mode_change_ok (orig_mode, new_mode, regno))
 406     {
 407       int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
 408       int use_nregs = hard_regno_nregs[copy_regno][new_mode];
 409       int copy_offset
 410         = GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
 411       int offset
 412         = GET_MODE_SIZE (orig_mode) - GET_MODE_SIZE (new_mode) - copy_offset;
 413       int byteoffset = offset % UNITS_PER_WORD;
 414       int wordoffset = offset - byteoffset;
 415
 416       offset = ((WORDS_BIG_ENDIAN ? wordoffset : 0)
 417                 + (BYTES_BIG_ENDIAN ? byteoffset : 0));
 418       regno += subreg_regno_offset (regno, orig_mode, offset, new_mode);
 419       if (HARD_REGNO_MODE_OK (regno, new_mode))
 420         return gen_raw_REG (new_mode, regno);
 421     }
 422   return NULL_RTX;
 423 }
 424
 425 /* Find the oldest copy of the value contained in REGNO that is in
 426    register class CL and has mode MODE.  If found, return an rtx
 427    of that oldest register, otherwise return NULL.  */
 428
 429 static rtx
 430 find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
 431 {
 432   unsigned int regno = REGNO (reg);
 433   machine_mode mode = GET_MODE (reg);
 434   unsigned int i;
 435
 436   /* If we are accessing REG in some mode other that what we set it in,
 437      make sure that the replacement is valid.  In particular, consider
 438         (set (reg:DI r11) (...))
 439         (set (reg:SI r9) (reg:SI r11))
 440         (set (reg:SI r10) (...))
 441         (set (...) (reg:DI r9))
 442      Replacing r9 with r11 is invalid.  */
 443   if (mode != vd->e[regno].mode)
 444     {
 445       if (hard_regno_nregs[regno][mode]
 446           > hard_regno_nregs[regno][vd->e[regno].mode])
 447         return NULL_RTX;
 448     }
 449
 450   for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
 451     {
 452       machine_mode oldmode = vd->e[i].mode;
 453       rtx new_rtx;
 454
 455       if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
 456         continue;
 457
 458       new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
 459       if (new_rtx)
 460         {
 461           ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
 462           REG_ATTRS (new_rtx) = REG_ATTRS (reg);
 463           REG_POINTER (new_rtx) = REG_POINTER (reg);
 464           return new_rtx;
 465         }
 466     }
 467
 468   return NULL_RTX;
 469 }
 470
 471 /* If possible, replace the register at *LOC with the oldest register
 472    in register class CL.  Return true if successfully replaced.  */
 473
 474 static bool
 475 replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx_insn *insn,
 476                           struct value_data *vd)
 477 {
 478   rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
 479   if (new_rtx && (!DEBUG_INSN_P (insn) || !skip_debug_insn_p))
 480     {
 481       if (DEBUG_INSN_P (insn))
 482         {
 483           struct queued_debug_insn_change *change;
 484
 485           if (dump_file)
 486             fprintf (dump_file, "debug_insn %u: queued replacing reg %u with %u\n",
 487                      INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
 488
 489           change = queued_debug_insn_change_pool.allocate ();
 490           change->next = vd->e[REGNO (new_rtx)].debug_insn_changes;
 491           change->insn = insn;
 492           change->loc = loc;
 493           change->new_rtx = new_rtx;
 494           vd->e[REGNO (new_rtx)].debug_insn_changes = change;
 495           ++vd->n_debug_insn_changes;
 496           return true;
 497         }
 498       if (dump_file)
 499         fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
 500                  INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
 501
 502       validate_change (insn, loc, new_rtx, 1);
 503       return true;
 504     }
 505   return false;
 506 }
 507
 508 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
 509    Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
 510    BASE_REG_CLASS depending on how the register is being considered.  */
 511
 512 static bool
 513 replace_oldest_value_addr (rtx *loc, enum reg_class cl,
 514                            machine_mode mode, addr_space_t as,
 515                            rtx_insn *insn, struct value_data *vd)
 516 {
 517   rtx x = *loc;
 518   RTX_CODE code = GET_CODE (x);
 519   const char *fmt;
 520   int i, j;
 521   bool changed = false;
 522
 523   switch (code)
 524     {
 525     case PLUS:
 526       if (DEBUG_INSN_P (insn))
 527         break;
 528
 529       {
 530         rtx orig_op0 = XEXP (x, 0);
 531         rtx orig_op1 = XEXP (x, 1);
 532         RTX_CODE code0 = GET_CODE (orig_op0);
 533         RTX_CODE code1 = GET_CODE (orig_op1);
 534         rtx op0 = orig_op0;
 535         rtx op1 = orig_op1;
 536         rtx *locI = NULL;
 537         rtx *locB = NULL;
 538         enum rtx_code index_code = SCRATCH;
 539
 540         if (GET_CODE (op0) == SUBREG)
 541           {
 542             op0 = SUBREG_REG (op0);
 543             code0 = GET_CODE (op0);
 544           }
 545
 546         if (GET_CODE (op1) == SUBREG)
 547           {
 548             op1 = SUBREG_REG (op1);
 549             code1 = GET_CODE (op1);
 550           }
 551
 552         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
 553             || code0 == ZERO_EXTEND || code1 == MEM)
 554           {
 555             locI = &XEXP (x, 0);
 556             locB = &XEXP (x, 1);
 557             index_code = GET_CODE (*locI);
 558           }
 559         else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
 560                  || code1 == ZERO_EXTEND || code0 == MEM)
 561           {
 562             locI = &XEXP (x, 1);
 563             locB = &XEXP (x, 0);
 564             index_code = GET_CODE (*locI);
 565           }
 566         else if (code0 == CONST_INT || code0 == CONST
 567                  || code0 == SYMBOL_REF || code0 == LABEL_REF)
 568           {
 569             locB = &XEXP (x, 1);
 570             index_code = GET_CODE (XEXP (x, 0));
 571           }
 572         else if (code1 == CONST_INT || code1 == CONST
 573                  || code1 == SYMBOL_REF || code1 == LABEL_REF)
 574           {
 575             locB = &XEXP (x, 0);
 576             index_code = GET_CODE (XEXP (x, 1));
 577           }
 578         else if (code0 == REG && code1 == REG)
 579           {
 580             int index_op;
 581             unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
 582
 583             if (REGNO_OK_FOR_INDEX_P (regno1)
 584                 && regno_ok_for_base_p (regno0, mode, as, PLUS, REG))
 585               index_op = 1;
 586             else if (REGNO_OK_FOR_INDEX_P (regno0)
 587                      && regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
 588               index_op = 0;
 589             else if (regno_ok_for_base_p (regno0, mode, as, PLUS, REG)
 590                      || REGNO_OK_FOR_INDEX_P (regno1))
 591               index_op = 1;
 592             else if (regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
 593               index_op = 0;
 594             else
 595               index_op = 1;
 596
 597             locI = &XEXP (x, index_op);
 598             locB = &XEXP (x, !index_op);
 599             index_code = GET_CODE (*locI);
 600           }
 601         else if (code0 == REG)
 602           {
 603             locI = &XEXP (x, 0);
 604             locB = &XEXP (x, 1);
 605             index_code = GET_CODE (*locI);
 606           }
 607         else if (code1 == REG)
 608           {
 609             locI = &XEXP (x, 1);
 610             locB = &XEXP (x, 0);
 611             index_code = GET_CODE (*locI);
 612           }
 613
 614         if (locI)
 615           changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS,
 616                                                 mode, as, insn, vd);
 617         if (locB)
 618           changed |= replace_oldest_value_addr (locB,
 619                                                 base_reg_class (mode, as, PLUS,
 620                                                                 index_code),
 621                                                 mode, as, insn, vd);
 622         return changed;
 623       }
 624
 625     case POST_INC:
 626     case POST_DEC:
 627     case POST_MODIFY:
 628     case PRE_INC:
 629     case PRE_DEC:
 630     case PRE_MODIFY:
 631       return false;
 632
 633     case MEM:
 634       return replace_oldest_value_mem (x, insn, vd);
 635
 636     case REG:
 637       return replace_oldest_value_reg (loc, cl, insn, vd);
 638
 639     default:
 640       break;
 641     }
 642
 643   fmt = GET_RTX_FORMAT (code);
 644   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 645     {
 646       if (fmt[i] == 'e')
 647         changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode, as,
 648                                               insn, vd);
 649       else if (fmt[i] == 'E')
 650         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 651           changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
 652                                                 mode, as, insn, vd);
 653     }
 654
 655   return changed;
 656 }
 657
 658 /* Similar to replace_oldest_value_reg, but X contains a memory.  */
 659
 660 static bool
 661 replace_oldest_value_mem (rtx x, rtx_insn *insn, struct value_data *vd)
 662 {
 663   enum reg_class cl;
 664
 665   if (DEBUG_INSN_P (insn))
 666     cl = ALL_REGS;
 667   else
 668     cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH);
 669
 670   return replace_oldest_value_addr (&XEXP (x, 0), cl,
 671                                     GET_MODE (x), MEM_ADDR_SPACE (x),
 672                                     insn, vd);
 673 }
 674
 675 /* Apply all queued updates for DEBUG_INSNs that change some reg to
 676    register REGNO.  */
 677
 678 static void
 679 apply_debug_insn_changes (struct value_data *vd, unsigned int regno)
 680 {
 681   struct queued_debug_insn_change *change;
 682   rtx_insn *last_insn = vd->e[regno].debug_insn_changes->insn;
 683
 684   for (change = vd->e[regno].debug_insn_changes;
 685        change;
 686        change = change->next)
 687     {
 688       if (last_insn != change->insn)
 689         {
 690           apply_change_group ();
 691           last_insn = change->insn;
 692         }
 693       validate_change (change->insn, change->loc, change->new_rtx, 1);
 694     }
 695   apply_change_group ();
 696 }
 697
 698 /* Called via note_uses, for all used registers in a real insn
 699    apply DEBUG_INSN changes that change registers to the used
 700    registers.  */
 701
 702 static void
 703 cprop_find_used_regs (rtx *loc, void *data)
 704 {
 705   struct value_data *const vd = (struct value_data *) data;
 706   subrtx_iterator::array_type array;
 707   FOR_EACH_SUBRTX (iter, array, *loc, NONCONST)
 708     {
 709       const_rtx x = *iter;
 710       if (REG_P (x))
 711         {
 712           unsigned int regno = REGNO (x);
 713           if (vd->e[regno].debug_insn_changes)
 714             {
 715               apply_debug_insn_changes (vd, regno);
 716               free_debug_insn_changes (vd, regno);
 717             }
 718         }
 719     }
 720 }
 721
 722 /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD.  */
 723
 724 static void
 725 kill_clobbered_values (rtx_insn *insn, struct value_data *vd)
 726 {
 727   note_stores (PATTERN (insn), kill_clobbered_value, vd);
 728
 729   if (CALL_P (insn))
 730     {
 731       rtx exp;
 732
 733       for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
 734         {
 735           rtx x = XEXP (exp, 0);
 736           if (GET_CODE (x) == CLOBBER)
 737             kill_value (SET_DEST (x), vd);
 738         }
 739     }
 740 }
 741
 742 /* Perform the forward copy propagation on basic block BB.  */
 743
 744 static bool
 745 copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 746 {
 747   bool anything_changed = false;
 748   rtx_insn *insn;
 749
 750   for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
 751     {
 752       int n_ops, i, predicated;
 753       bool is_asm, any_replacements;
 754       rtx set;
 755       rtx link;
 756       bool replaced[MAX_RECOG_OPERANDS];
 757       bool changed = false;
 758       struct kill_set_value_data ksvd;
 759
 760       if (!NONDEBUG_INSN_P (insn))
 761         {
 762           if (DEBUG_INSN_P (insn))
 763             {
 764               rtx loc = INSN_VAR_LOCATION_LOC (insn);
 765               if (!VAR_LOC_UNKNOWN_P (loc))
 766                 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn),
 767                                            ALL_REGS, GET_MODE (loc),
 768                                            ADDR_SPACE_GENERIC, insn, vd);
 769             }
 770
 771           if (insn == BB_END (bb))
 772             break;
 773           else
 774             continue;
 775         }
 776
 777       set = single_set (insn);
 778       extract_constrain_insn (insn);
 779       preprocess_constraints (insn);
 780       const operand_alternative *op_alt = which_op_alt ();
 781       n_ops = recog_data.n_operands;
 782       is_asm = asm_noperands (PATTERN (insn)) >= 0;
 783
 784       /* Simplify the code below by promoting OP_OUT to OP_INOUT
 785          in predicated instructions.  */
 786
 787       predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
 788       for (i = 0; i < n_ops; ++i)
 789         {
 790           int matches = op_alt[i].matches;
 791           if (matches >= 0 || op_alt[i].matched >= 0
 792               || (predicated && recog_data.operand_type[i] == OP_OUT))
 793             recog_data.operand_type[i] = OP_INOUT;
 794         }
 795
 796       /* Apply changes to earlier DEBUG_INSNs if possible.  */
 797       if (vd->n_debug_insn_changes)
 798         note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
 799
 800       /* For each earlyclobber operand, zap the value data.  */
 801       for (i = 0; i < n_ops; i++)
 802         if (op_alt[i].earlyclobber)
 803           kill_value (recog_data.operand[i], vd);
 804
 805       /* Within asms, a clobber cannot overlap inputs or outputs.
 806          I wouldn't think this were true for regular insns, but
 807          scan_rtx treats them like that...  */
 808       kill_clobbered_values (insn, vd);
 809
 810       /* Kill all auto-incremented values.  */
 811       /* ??? REG_INC is useless, since stack pushes aren't done that way.  */
 812       kill_autoinc_value (insn, vd);
 813
 814       /* Kill all early-clobbered operands.  */
 815       for (i = 0; i < n_ops; i++)
 816         if (op_alt[i].earlyclobber)
 817           kill_value (recog_data.operand[i], vd);
 818
 819       /* If we have dead sets in the insn, then we need to note these as we
 820          would clobbers.  */
 821       for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
 822         {
 823           if (REG_NOTE_KIND (link) == REG_UNUSED)
 824             {
 825               kill_value (XEXP (link, 0), vd);
 826               /* Furthermore, if the insn looked like a single-set,
 827                  but the dead store kills the source value of that
 828                  set, then we can no-longer use the plain move
 829                  special case below.  */
 830               if (set
 831                   && reg_overlap_mentioned_p (XEXP (link, 0), SET_SRC (set)))
 832                 set = NULL;
 833             }
 834         }
 835
 836       /* Special-case plain move instructions, since we may well
 837          be able to do the move from a different register class.  */
 838       if (set && REG_P (SET_SRC (set)))
 839         {
 840           rtx src = SET_SRC (set);
 841           unsigned int regno = REGNO (src);
 842           machine_mode mode = GET_MODE (src);
 843           unsigned int i;
 844           rtx new_rtx;
 845
 846           /* If we are accessing SRC in some mode other that what we
 847              set it in, make sure that the replacement is valid.  */
 848           if (mode != vd->e[regno].mode)
 849             {
 850               if (hard_regno_nregs[regno][mode]
 851                   > hard_regno_nregs[regno][vd->e[regno].mode])
 852                 goto no_move_special_case;
 853
 854               /* And likewise, if we are narrowing on big endian the transformation
 855                  is also invalid.  */
 856               if (hard_regno_nregs[regno][mode]
 857                   < hard_regno_nregs[regno][vd->e[regno].mode]
 858                   && (GET_MODE_SIZE (vd->e[regno].mode) > UNITS_PER_WORD
 859                       ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
 860                 goto no_move_special_case;
 861             }
 862
 863           /* If the destination is also a register, try to find a source
 864              register in the same class.  */
 865           if (REG_P (SET_DEST (set)))
 866             {
 867               new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
 868               if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
 869                 {
 870                   if (dump_file)
 871                     fprintf (dump_file,
 872                              "insn %u: replaced reg %u with %u\n",
 873                              INSN_UID (insn), regno, REGNO (new_rtx));
 874                   changed = true;
 875                   goto did_replacement;
 876                 }
 877               /* We need to re-extract as validate_change clobbers
 878                  recog_data.  */
 879               extract_constrain_insn (insn);
 880               preprocess_constraints (insn);
 881             }
 882
 883           /* Otherwise, try all valid registers and see if its valid.  */
 884           for (i = vd->e[regno].oldest_regno; i != regno;
 885                i = vd->e[i].next_regno)
 886             {
 887               new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
 888                                        mode, i, regno);
 889               if (new_rtx != NULL_RTX)
 890                 {
 891                   if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
 892                     {
 893                       ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
 894                       REG_ATTRS (new_rtx) = REG_ATTRS (src);
 895                       REG_POINTER (new_rtx) = REG_POINTER (src);
 896                       if (dump_file)
 897                         fprintf (dump_file,
 898                                  "insn %u: replaced reg %u with %u\n",
 899                                  INSN_UID (insn), regno, REGNO (new_rtx));
 900                       changed = true;
 901                       goto did_replacement;
 902                     }
 903                   /* We need to re-extract as validate_change clobbers
 904                      recog_data.  */
 905                   extract_constrain_insn (insn);
 906                   preprocess_constraints (insn);
 907                 }
 908             }
 909         }
 910       no_move_special_case:
 911
 912       any_replacements = false;
 913
 914       /* For each input operand, replace a hard register with the
 915          eldest live copy that's in an appropriate register class.  */
 916       for (i = 0; i < n_ops; i++)
 917         {
 918           replaced[i] = false;
 919
 920           /* Don't scan match_operand here, since we've no reg class
 921              information to pass down.  Any operands that we could
 922              substitute in will be represented elsewhere.  */
 923           if (recog_data.constraints[i][0] == '\0')
 924             continue;
 925
 926           /* Don't replace in asms intentionally referencing hard regs.  */
 927           if (is_asm && REG_P (recog_data.operand[i])
 928               && (REGNO (recog_data.operand[i])
 929                   == ORIGINAL_REGNO (recog_data.operand[i])))
 930             continue;
 931
 932           if (recog_data.operand_type[i] == OP_IN)
 933             {
 934               if (op_alt[i].is_address)
 935                 replaced[i]
 936                   = replace_oldest_value_addr (recog_data.operand_loc[i],
 937                                                alternative_class (op_alt, i),
 938                                                VOIDmode, ADDR_SPACE_GENERIC,
 939                                                insn, vd);
 940               else if (REG_P (recog_data.operand[i]))
 941                 replaced[i]
 942                   = replace_oldest_value_reg (recog_data.operand_loc[i],
 943                                               alternative_class (op_alt, i),
 944                                               insn, vd);
 945               else if (MEM_P (recog_data.operand[i]))
 946                 replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
 947                                                         insn, vd);
 948             }
 949           else if (MEM_P (recog_data.operand[i]))
 950             replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
 951                                                     insn, vd);
 952
 953           /* If we performed any replacement, update match_dups.  */
 954           if (replaced[i])
 955             {
 956               int j;
 957               rtx new_rtx;
 958
 959               new_rtx = *recog_data.operand_loc[i];
 960               recog_data.operand[i] = new_rtx;
 961               for (j = 0; j < recog_data.n_dups; j++)
 962                 if (recog_data.dup_num[j] == i)
 963                   validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
 964
 965               any_replacements = true;
 966             }
 967         }
 968
 969       if (any_replacements)
 970         {
 971           if (! apply_change_group ())
 972             {
 973               for (i = 0; i < n_ops; i++)
 974                 if (replaced[i])
 975                   {
 976                     rtx old = *recog_data.operand_loc[i];
 977                     recog_data.operand[i] = old;
 978                   }
 979
 980               if (dump_file)
 981                 fprintf (dump_file,
 982                          "insn %u: reg replacements not verified\n",
 983                          INSN_UID (insn));
 984             }
 985           else
 986             changed = true;
 987         }
 988
 989     did_replacement:
 990       if (changed)
 991         {
 992           anything_changed = true;
 993
 994           /* If something changed, perhaps further changes to earlier
 995              DEBUG_INSNs can be applied.  */
 996           if (vd->n_debug_insn_changes)
 997             note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
 998         }
 999
1000       ksvd.vd = vd;
1001       ksvd.ignore_set_reg = NULL_RTX;
1002
1003       /* Clobber call-clobbered registers.  */
1004       if (CALL_P (insn))
1005         {
1006           unsigned int set_regno = INVALID_REGNUM;
1007           unsigned int set_nregs = 0;
1008           unsigned int regno;
1009           rtx exp;
1010           HARD_REG_SET regs_invalidated_by_this_call;
1011
1012           for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
1013             {
1014               rtx x = XEXP (exp, 0);
1015               if (GET_CODE (x) == SET)
1016                 {
1017                   rtx dest = SET_DEST (x);
1018                   kill_value (dest, vd);
1019                   set_value_regno (REGNO (dest), GET_MODE (dest), vd);
1020                   copy_value (dest, SET_SRC (x), vd);
1021                   ksvd.ignore_set_reg = dest;
1022                   set_regno = REGNO (dest);
1023                   set_nregs = REG_NREGS (dest);
1024                   break;
1025                 }
1026             }
1027
1028           get_call_reg_set_usage (insn,
1029                                   &regs_invalidated_by_this_call,
1030                                   regs_invalidated_by_call);
1031           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1032             if ((TEST_HARD_REG_BIT (regs_invalidated_by_this_call, regno)
1033                  || HARD_REGNO_CALL_PART_CLOBBERED (regno, vd->e[regno].mode))
1034                 && (regno < set_regno || regno >= set_regno + set_nregs))
1035               kill_value_regno (regno, 1, vd);
1036
1037           /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1038              of the SET isn't in regs_invalidated_by_call hard reg set,
1039              but instead among CLOBBERs on the CALL_INSN, we could wrongly
1040              assume the value in it is still live.  */
1041           if (ksvd.ignore_set_reg)
1042             kill_clobbered_values (insn, vd);
1043         }
1044
1045       bool copy_p = (set
1046                      && REG_P (SET_DEST (set))
1047                      && REG_P (SET_SRC (set)));
1048       bool noop_p = (copy_p
1049                      && rtx_equal_p (SET_DEST (set), SET_SRC (set)));
1050
1051       if (!noop_p)
1052         {
1053           /* Notice stores.  */
1054           note_stores (PATTERN (insn), kill_set_value, &ksvd);
1055
1056           /* Notice copies.  */
1057           if (copy_p)
1058             copy_value (SET_DEST (set), SET_SRC (set), vd);
1059         }
1060
1061       if (insn == BB_END (bb))
1062         break;
1063     }
1064
1065   return anything_changed;
1066 }
1067
1068 /* Dump the value chain data to stderr.  */
1069
1070 DEBUG_FUNCTION void
1071 debug_value_data (struct value_data *vd)
1072 {
1073   HARD_REG_SET set;
1074   unsigned int i, j;
1075
1076   CLEAR_HARD_REG_SET (set);
1077
1078   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1079     if (vd->e[i].oldest_regno == i)
1080       {
1081         if (vd->e[i].mode == VOIDmode)
1082           {
1083             if (vd->e[i].next_regno != INVALID_REGNUM)
1084               fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
1085                        i, vd->e[i].next_regno);
1086             continue;
1087           }
1088
1089         SET_HARD_REG_BIT (set, i);
1090         fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
1091
1092         for (j = vd->e[i].next_regno;
1093              j != INVALID_REGNUM;
1094              j = vd->e[j].next_regno)
1095           {
1096             if (TEST_HARD_REG_BIT (set, j))
1097               {
1098                 fprintf (stderr, "[%u] Loop in regno chain\n", j);
1099                 return;
1100               }
1101
1102             if (vd->e[j].oldest_regno != i)
1103               {
1104                 fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
1105                          j, vd->e[j].oldest_regno);
1106                 return;
1107               }
1108             SET_HARD_REG_BIT (set, j);
1109             fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
1110           }
1111         fputc ('\n', stderr);
1112       }
1113
1114   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1115     if (! TEST_HARD_REG_BIT (set, i)
1116         && (vd->e[i].mode != VOIDmode
1117             || vd->e[i].oldest_regno != i
1118             || vd->e[i].next_regno != INVALID_REGNUM))
1119       fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
1120                i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1121                vd->e[i].next_regno);
1122 }
1123
1124 /* Do copyprop_hardreg_forward_1 for a single basic block BB.
1125    DEBUG_INSN is skipped since we do not want to involve DF related
1126    staff as how it is handled in function pass_cprop_hardreg::execute.
1127
1128    NOTE: Currently it is only used for shrink-wrap.  Maybe extend it
1129    to handle DEBUG_INSN for other uses.  */
1130
1131 void
1132 copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
1133 {
1134   struct value_data *vd;
1135   vd = XNEWVEC (struct value_data, 1);
1136   init_value_data (vd);
1137
1138   skip_debug_insn_p = true;
1139   copyprop_hardreg_forward_1 (bb, vd);
1140   free (vd);
1141   skip_debug_insn_p = false;
1142 }
1143
1144 #ifdef ENABLE_CHECKING
1145 static void
1146 validate_value_data (struct value_data *vd)
1147 {
1148   HARD_REG_SET set;
1149   unsigned int i, j;
1150
1151   CLEAR_HARD_REG_SET (set);
1152
1153   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1154     if (vd->e[i].oldest_regno == i)
1155       {
1156         if (vd->e[i].mode == VOIDmode)
1157           {
1158             if (vd->e[i].next_regno != INVALID_REGNUM)
1159               internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1160                               i, vd->e[i].next_regno);
1161             continue;
1162           }
1163
1164         SET_HARD_REG_BIT (set, i);
1165
1166         for (j = vd->e[i].next_regno;
1167              j != INVALID_REGNUM;
1168              j = vd->e[j].next_regno)
1169           {
1170             if (TEST_HARD_REG_BIT (set, j))
1171               internal_error ("validate_value_data: Loop in regno chain (%u)",
1172                               j);
1173             if (vd->e[j].oldest_regno != i)
1174               internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1175                               j, vd->e[j].oldest_regno);
1176
1177             SET_HARD_REG_BIT (set, j);
1178           }
1179       }
1180
1181   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1182     if (! TEST_HARD_REG_BIT (set, i)
1183         && (vd->e[i].mode != VOIDmode
1184             || vd->e[i].oldest_regno != i
1185             || vd->e[i].next_regno != INVALID_REGNUM))
1186       internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1187                       i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1188                       vd->e[i].next_regno);
1189 }
1190 #endif
1191 \f
1192 namespace {
1193
1194 const pass_data pass_data_cprop_hardreg =
1195 {
1196   RTL_PASS, /* type */
1197   "cprop_hardreg", /* name */
1198   OPTGROUP_NONE, /* optinfo_flags */
1199   TV_CPROP_REGISTERS, /* tv_id */
1200   0, /* properties_required */
1201   0, /* properties_provided */
1202   0, /* properties_destroyed */
1203   0, /* todo_flags_start */
1204   TODO_df_finish, /* todo_flags_finish */
1205 };
1206
1207 class pass_cprop_hardreg : public rtl_opt_pass
1208 {
1209 public:
1210   pass_cprop_hardreg (gcc::context *ctxt)
1211     : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
1212   {}
1213
1214   /* opt_pass methods: */
1215   virtual bool gate (function *)
1216     {
1217       return (optimize > 0 && (flag_cprop_registers));
1218     }
1219
1220   virtual unsigned int execute (function *);
1221
1222 }; // class pass_cprop_hardreg
1223
1224 unsigned int
1225 pass_cprop_hardreg::execute (function *fun)
1226 {
1227   struct value_data *all_vd;
1228   basic_block bb;
1229   sbitmap visited;
1230   bool analyze_called = false;
1231
1232   all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
1233
1234   visited = sbitmap_alloc (last_basic_block_for_fn (fun));
1235   bitmap_clear (visited);
1236
1237   FOR_EACH_BB_FN (bb, fun)
1238     {
1239       bitmap_set_bit (visited, bb->index);
1240
1241       /* If a block has a single predecessor, that we've already
1242          processed, begin with the value data that was live at
1243          the end of the predecessor block.  */
1244       /* ??? Ought to use more intelligent queuing of blocks.  */
1245       if (single_pred_p (bb)
1246           && bitmap_bit_p (visited, single_pred (bb)->index)
1247           && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
1248         {
1249           all_vd[bb->index] = all_vd[single_pred (bb)->index];
1250           if (all_vd[bb->index].n_debug_insn_changes)
1251             {
1252               unsigned int regno;
1253
1254               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1255                 {
1256                   if (all_vd[bb->index].e[regno].debug_insn_changes)
1257                     {
1258                       all_vd[bb->index].e[regno].debug_insn_changes = NULL;
1259                       if (--all_vd[bb->index].n_debug_insn_changes == 0)
1260                         break;
1261                     }
1262                 }
1263             }
1264         }
1265       else
1266         init_value_data (all_vd + bb->index);
1267
1268       copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
1269     }
1270
1271   if (MAY_HAVE_DEBUG_INSNS)
1272     {
1273       FOR_EACH_BB_FN (bb, fun)
1274         if (bitmap_bit_p (visited, bb->index)
1275             && all_vd[bb->index].n_debug_insn_changes)
1276           {
1277             unsigned int regno;
1278             bitmap live;
1279
1280             if (!analyze_called)
1281               {
1282                 df_analyze ();
1283                 analyze_called = true;
1284               }
1285             live = df_get_live_out (bb);
1286             for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1287               if (all_vd[bb->index].e[regno].debug_insn_changes)
1288                 {
1289                   if (REGNO_REG_SET_P (live, regno))
1290                     apply_debug_insn_changes (all_vd + bb->index, regno);
1291                   if (all_vd[bb->index].n_debug_insn_changes == 0)
1292                     break;
1293                 }
1294           }
1295
1296       queued_debug_insn_change_pool.release ();
1297     }
1298
1299   sbitmap_free (visited);
1300   free (all_vd);
1301   return 0;
1302 }
1303
1304 } // anon namespace
1305
1306 rtl_opt_pass *
1307 make_pass_cprop_hardreg (gcc::context *ctxt)
1308 {
1309   return new pass_cprop_hardreg (ctxt);
1310 }