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