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