]> 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
PR c++/51253
[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 {
748 int n_ops, i, alt, predicated;
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 ();
778 alt = which_alternative;
779 n_ops = recog_data.n_operands;
780 is_asm = asm_noperands (PATTERN (insn)) >= 0;
781
782 /* Simplify the code below by rewriting things to reflect
783 matching constraints. Also promote OP_OUT to OP_INOUT
784 in predicated instructions. */
785
786 predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
787 for (i = 0; i < n_ops; ++i)
788 {
789 int matches = recog_op_alt[i][alt].matches;
790 if (matches >= 0)
791 recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
792 if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
793 || (predicated && recog_data.operand_type[i] == OP_OUT))
794 recog_data.operand_type[i] = OP_INOUT;
795 }
796
2058ec71 797 /* Apply changes to earlier DEBUG_INSNs if possible. */
798 if (vd->n_debug_insn_changes)
799 note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
800
2d4749b6 801 /* For each earlyclobber operand, zap the value data. */
802 for (i = 0; i < n_ops; i++)
803 if (recog_op_alt[i][alt].earlyclobber)
804 kill_value (recog_data.operand[i], vd);
805
806 /* Within asms, a clobber cannot overlap inputs or outputs.
807 I wouldn't think this were true for regular insns, but
808 scan_rtx treats them like that... */
809 note_stores (PATTERN (insn), kill_clobbered_value, vd);
810
811 /* Kill all auto-incremented values. */
812 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
813 for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
814
815 /* Kill all early-clobbered operands. */
816 for (i = 0; i < n_ops; i++)
817 if (recog_op_alt[i][alt].earlyclobber)
818 kill_value (recog_data.operand[i], vd);
819
ff5a75fc 820 /* If we have dead sets in the insn, then we need to note these as we
821 would clobbers. */
822 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
823 {
824 if (REG_NOTE_KIND (link) == REG_UNUSED)
825 {
826 kill_value (XEXP (link, 0), vd);
827 /* Furthermore, if the insn looked like a single-set,
828 but the dead store kills the source value of that
829 set, then we can no-longer use the plain move
830 special case below. */
831 if (set
832 && reg_overlap_mentioned_p (XEXP (link, 0), SET_SRC (set)))
833 set = NULL;
834 }
835 }
836
2d4749b6 837 /* Special-case plain move instructions, since we may well
838 be able to do the move from a different register class. */
839 if (set && REG_P (SET_SRC (set)))
840 {
841 rtx src = SET_SRC (set);
842 unsigned int regno = REGNO (src);
843 enum machine_mode mode = GET_MODE (src);
844 unsigned int i;
845 rtx new_rtx;
846
847 /* If we are accessing SRC in some mode other that what we
848 set it in, make sure that the replacement is valid. */
849 if (mode != vd->e[regno].mode)
850 {
851 if (hard_regno_nregs[regno][mode]
852 > hard_regno_nregs[regno][vd->e[regno].mode])
853 goto no_move_special_case;
417491d1 854
855 /* And likewise, if we are narrowing on big endian the transformation
856 is also invalid. */
857 if (hard_regno_nregs[regno][mode]
858 < hard_regno_nregs[regno][vd->e[regno].mode]
859 && (GET_MODE_SIZE (vd->e[regno].mode) > UNITS_PER_WORD
860 ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
861 goto no_move_special_case;
2d4749b6 862 }
863
864 /* If the destination is also a register, try to find a source
865 register in the same class. */
866 if (REG_P (SET_DEST (set)))
867 {
868 new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
869 if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
870 {
871 if (dump_file)
872 fprintf (dump_file,
873 "insn %u: replaced reg %u with %u\n",
874 INSN_UID (insn), regno, REGNO (new_rtx));
875 changed = true;
876 goto did_replacement;
877 }
cc7416ff 878 /* We need to re-extract as validate_change clobbers
879 recog_data. */
880 extract_insn (insn);
881 if (! constrain_operands (1))
882 fatal_insn_not_found (insn);
883 preprocess_constraints ();
2d4749b6 884 }
885
886 /* Otherwise, try all valid registers and see if its valid. */
887 for (i = vd->e[regno].oldest_regno; i != regno;
888 i = vd->e[i].next_regno)
889 {
890 new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
891 mode, i, regno);
892 if (new_rtx != NULL_RTX)
893 {
894 if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
895 {
896 ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
897 REG_ATTRS (new_rtx) = REG_ATTRS (src);
898 REG_POINTER (new_rtx) = REG_POINTER (src);
899 if (dump_file)
900 fprintf (dump_file,
901 "insn %u: replaced reg %u with %u\n",
902 INSN_UID (insn), regno, REGNO (new_rtx));
903 changed = true;
904 goto did_replacement;
905 }
cc7416ff 906 /* We need to re-extract as validate_change clobbers
907 recog_data. */
908 extract_insn (insn);
909 if (! constrain_operands (1))
910 fatal_insn_not_found (insn);
911 preprocess_constraints ();
2d4749b6 912 }
913 }
914 }
915 no_move_special_case:
916
917 any_replacements = false;
918
919 /* For each input operand, replace a hard register with the
920 eldest live copy that's in an appropriate register class. */
921 for (i = 0; i < n_ops; i++)
922 {
923 replaced[i] = false;
924
925 /* Don't scan match_operand here, since we've no reg class
926 information to pass down. Any operands that we could
927 substitute in will be represented elsewhere. */
928 if (recog_data.constraints[i][0] == '\0')
929 continue;
930
931 /* Don't replace in asms intentionally referencing hard regs. */
932 if (is_asm && REG_P (recog_data.operand[i])
933 && (REGNO (recog_data.operand[i])
934 == ORIGINAL_REGNO (recog_data.operand[i])))
935 continue;
936
937 if (recog_data.operand_type[i] == OP_IN)
938 {
939 if (recog_op_alt[i][alt].is_address)
940 replaced[i]
941 = replace_oldest_value_addr (recog_data.operand_loc[i],
942 recog_op_alt[i][alt].cl,
f8a8fc7b 943 VOIDmode, ADDR_SPACE_GENERIC,
944 insn, vd);
2d4749b6 945 else if (REG_P (recog_data.operand[i]))
946 replaced[i]
947 = replace_oldest_value_reg (recog_data.operand_loc[i],
948 recog_op_alt[i][alt].cl,
949 insn, vd);
950 else if (MEM_P (recog_data.operand[i]))
951 replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
952 insn, vd);
953 }
954 else if (MEM_P (recog_data.operand[i]))
955 replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
956 insn, vd);
957
958 /* If we performed any replacement, update match_dups. */
959 if (replaced[i])
960 {
961 int j;
962 rtx new_rtx;
963
964 new_rtx = *recog_data.operand_loc[i];
965 recog_data.operand[i] = new_rtx;
966 for (j = 0; j < recog_data.n_dups; j++)
967 if (recog_data.dup_num[j] == i)
968 validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
969
970 any_replacements = true;
971 }
972 }
973
974 if (any_replacements)
975 {
976 if (! apply_change_group ())
977 {
978 for (i = 0; i < n_ops; i++)
979 if (replaced[i])
980 {
981 rtx old = *recog_data.operand_loc[i];
982 recog_data.operand[i] = old;
983 }
984
985 if (dump_file)
986 fprintf (dump_file,
987 "insn %u: reg replacements not verified\n",
988 INSN_UID (insn));
989 }
990 else
991 changed = true;
992 }
993
994 did_replacement:
9845d120 995 if (changed)
c7458ee3 996 {
997 anything_changed = true;
998
999 /* If something changed, perhaps further changes to earlier
1000 DEBUG_INSNs can be applied. */
1001 if (vd->n_debug_insn_changes)
1002 note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
1003 }
9845d120 1004
c8010b80 1005 ksvd.vd = vd;
1006 ksvd.ignore_set_reg = NULL_RTX;
1007
2d4749b6 1008 /* Clobber call-clobbered registers. */
1009 if (CALL_P (insn))
c8010b80 1010 {
24ec6636 1011 unsigned int set_regno = INVALID_REGNUM;
1012 unsigned int set_nregs = 0;
1013 unsigned int regno;
c8010b80 1014 rtx exp;
24ec6636 1015
c8010b80 1016 for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
1017 {
1018 rtx x = XEXP (exp, 0);
1019 if (GET_CODE (x) == SET)
1020 {
1021 rtx dest = SET_DEST (x);
1022 kill_value (dest, vd);
1023 set_value_regno (REGNO (dest), GET_MODE (dest), vd);
1024 copy_value (dest, SET_SRC (x), vd);
1025 ksvd.ignore_set_reg = dest;
1026 set_regno = REGNO (dest);
1027 set_nregs
1028 = hard_regno_nregs[set_regno][GET_MODE (dest)];
1029 break;
1030 }
1031 }
24ec6636 1032
1aafbb7e 1033 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1034 if ((TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
1035 || HARD_REGNO_CALL_PART_CLOBBERED (regno, vd->e[regno].mode))
1036 && (regno < set_regno || regno >= set_regno + set_nregs))
24ec6636 1037 kill_value_regno (regno, 1, vd);
ca719585 1038
1039 /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1040 of the SET isn't in regs_invalidated_by_call hard reg set,
1041 but instead among CLOBBERs on the CALL_INSN, we could wrongly
1042 assume the value in it is still live. */
1043 if (ksvd.ignore_set_reg)
1044 note_stores (PATTERN (insn), kill_clobbered_value, vd);
c8010b80 1045 }
2d4749b6 1046
1047 /* Notice stores. */
c8010b80 1048 note_stores (PATTERN (insn), kill_set_value, &ksvd);
2d4749b6 1049
1050 /* Notice copies. */
1051 if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
1052 copy_value (SET_DEST (set), SET_SRC (set), vd);
1053
1054 if (insn == BB_END (bb))
1055 break;
1056 }
1057
9845d120 1058 return anything_changed;
2d4749b6 1059}
1060
2d4749b6 1061/* Dump the value chain data to stderr. */
1062
4b987fac 1063DEBUG_FUNCTION void
2d4749b6 1064debug_value_data (struct value_data *vd)
1065{
1066 HARD_REG_SET set;
1067 unsigned int i, j;
1068
1069 CLEAR_HARD_REG_SET (set);
1070
1071 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1072 if (vd->e[i].oldest_regno == i)
1073 {
1074 if (vd->e[i].mode == VOIDmode)
1075 {
1076 if (vd->e[i].next_regno != INVALID_REGNUM)
1077 fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
1078 i, vd->e[i].next_regno);
1079 continue;
1080 }
1081
1082 SET_HARD_REG_BIT (set, i);
1083 fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
1084
1085 for (j = vd->e[i].next_regno;
1086 j != INVALID_REGNUM;
1087 j = vd->e[j].next_regno)
1088 {
1089 if (TEST_HARD_REG_BIT (set, j))
1090 {
1091 fprintf (stderr, "[%u] Loop in regno chain\n", j);
1092 return;
1093 }
1094
1095 if (vd->e[j].oldest_regno != i)
1096 {
1097 fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
1098 j, vd->e[j].oldest_regno);
1099 return;
1100 }
1101 SET_HARD_REG_BIT (set, j);
1102 fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
1103 }
1104 fputc ('\n', stderr);
1105 }
1106
1107 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1108 if (! TEST_HARD_REG_BIT (set, i)
1109 && (vd->e[i].mode != VOIDmode
1110 || vd->e[i].oldest_regno != i
1111 || vd->e[i].next_regno != INVALID_REGNUM))
1112 fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
1113 i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1114 vd->e[i].next_regno);
1115}
1116
59483f68 1117/* Do copyprop_hardreg_forward_1 for a single basic block BB.
1118 DEBUG_INSN is skipped since we do not want to involve DF related
1119 staff as how it is handled in function pass_cprop_hardreg::execute.
1120
1121 NOTE: Currently it is only used for shrink-wrap. Maybe extend it
1122 to handle DEBUG_INSN for other uses. */
1123
1124void
1125copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
1126{
1127 struct value_data *vd;
1128 vd = XNEWVEC (struct value_data, 1);
1129 init_value_data (vd);
1130
1131 skip_debug_insn_p = true;
1132 copyprop_hardreg_forward_1 (bb, vd);
1133 free (vd);
1134 skip_debug_insn_p = false;
1135}
1136
2d4749b6 1137#ifdef ENABLE_CHECKING
1138static void
1139validate_value_data (struct value_data *vd)
1140{
1141 HARD_REG_SET set;
1142 unsigned int i, j;
1143
1144 CLEAR_HARD_REG_SET (set);
1145
1146 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1147 if (vd->e[i].oldest_regno == i)
1148 {
1149 if (vd->e[i].mode == VOIDmode)
1150 {
1151 if (vd->e[i].next_regno != INVALID_REGNUM)
1152 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1153 i, vd->e[i].next_regno);
1154 continue;
1155 }
1156
1157 SET_HARD_REG_BIT (set, i);
1158
1159 for (j = vd->e[i].next_regno;
1160 j != INVALID_REGNUM;
1161 j = vd->e[j].next_regno)
1162 {
1163 if (TEST_HARD_REG_BIT (set, j))
1164 internal_error ("validate_value_data: Loop in regno chain (%u)",
1165 j);
1166 if (vd->e[j].oldest_regno != i)
1167 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1168 j, vd->e[j].oldest_regno);
1169
1170 SET_HARD_REG_BIT (set, j);
1171 }
1172 }
1173
1174 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1175 if (! TEST_HARD_REG_BIT (set, i)
1176 && (vd->e[i].mode != VOIDmode
1177 || vd->e[i].oldest_regno != i
1178 || vd->e[i].next_regno != INVALID_REGNUM))
1179 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1180 i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1181 vd->e[i].next_regno);
1182}
1183#endif
1184\f
cbe8bda8 1185namespace {
1186
1187const pass_data pass_data_cprop_hardreg =
2d4749b6 1188{
cbe8bda8 1189 RTL_PASS, /* type */
1190 "cprop_hardreg", /* name */
1191 OPTGROUP_NONE, /* optinfo_flags */
cbe8bda8 1192 true, /* has_execute */
1193 TV_CPROP_REGISTERS, /* tv_id */
1194 0, /* properties_required */
1195 0, /* properties_provided */
1196 0, /* properties_destroyed */
1197 0, /* todo_flags_start */
8b88439e 1198 TODO_df_finish, /* todo_flags_finish */
2d4749b6 1199};
cbe8bda8 1200
1201class pass_cprop_hardreg : public rtl_opt_pass
1202{
1203public:
9af5ce0c 1204 pass_cprop_hardreg (gcc::context *ctxt)
1205 : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
cbe8bda8 1206 {}
1207
1208 /* opt_pass methods: */
31315c24 1209 virtual bool gate (function *)
1210 {
1211 return (optimize > 0 && (flag_cprop_registers));
1212 }
1213
65b0537f 1214 virtual unsigned int execute (function *);
cbe8bda8 1215
1216}; // class pass_cprop_hardreg
1217
65b0537f 1218unsigned int
1219pass_cprop_hardreg::execute (function *fun)
1220{
1221 struct value_data *all_vd;
1222 basic_block bb;
1223 sbitmap visited;
1224 bool analyze_called = false;
1225
1226 all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
1227
1228 visited = sbitmap_alloc (last_basic_block_for_fn (fun));
1229 bitmap_clear (visited);
1230
1231 if (MAY_HAVE_DEBUG_INSNS)
1232 debug_insn_changes_pool
1233 = create_alloc_pool ("debug insn changes pool",
1234 sizeof (struct queued_debug_insn_change), 256);
1235
1236 FOR_EACH_BB_FN (bb, fun)
1237 {
1238 bitmap_set_bit (visited, bb->index);
1239
1240 /* If a block has a single predecessor, that we've already
1241 processed, begin with the value data that was live at
1242 the end of the predecessor block. */
1243 /* ??? Ought to use more intelligent queuing of blocks. */
1244 if (single_pred_p (bb)
1245 && bitmap_bit_p (visited, single_pred (bb)->index)
1246 && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
1247 {
1248 all_vd[bb->index] = all_vd[single_pred (bb)->index];
1249 if (all_vd[bb->index].n_debug_insn_changes)
1250 {
1251 unsigned int regno;
1252
1253 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1254 {
1255 if (all_vd[bb->index].e[regno].debug_insn_changes)
1256 {
1257 all_vd[bb->index].e[regno].debug_insn_changes = NULL;
1258 if (--all_vd[bb->index].n_debug_insn_changes == 0)
1259 break;
1260 }
1261 }
1262 }
1263 }
1264 else
1265 init_value_data (all_vd + bb->index);
1266
1267 copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
1268 }
1269
1270 if (MAY_HAVE_DEBUG_INSNS)
1271 {
1272 FOR_EACH_BB_FN (bb, fun)
1273 if (bitmap_bit_p (visited, bb->index)
1274 && all_vd[bb->index].n_debug_insn_changes)
1275 {
1276 unsigned int regno;
1277 bitmap live;
1278
1279 if (!analyze_called)
1280 {
1281 df_analyze ();
1282 analyze_called = true;
1283 }
1284 live = df_get_live_out (bb);
1285 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1286 if (all_vd[bb->index].e[regno].debug_insn_changes)
1287 {
1288 if (REGNO_REG_SET_P (live, regno))
1289 apply_debug_insn_changes (all_vd + bb->index, regno);
1290 if (all_vd[bb->index].n_debug_insn_changes == 0)
1291 break;
1292 }
1293 }
1294
1295 free_alloc_pool (debug_insn_changes_pool);
1296 }
1297
1298 sbitmap_free (visited);
1299 free (all_vd);
1300 return 0;
1301}
1302
cbe8bda8 1303} // anon namespace
1304
1305rtl_opt_pass *
1306make_pass_cprop_hardreg (gcc::context *ctxt)
1307{
1308 return new pass_cprop_hardreg (ctxt);
1309}
Mirror of https://gcc.gnu.org/git/gcc.git