Daily bump.
[official-gcc.git] / gcc / valtrack.c
blob027d883044a584a88fb3866666e3b999af956ea8
1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010-2021 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "rtl.h"
27 #include "df.h"
28 #include "valtrack.h"
29 #include "regs.h"
30 #include "memmodel.h"
31 #include "emit-rtl.h"
32 #include "rtl-iter.h"
34 /* gen_lowpart_no_emit hook implementation for DEBUG_INSNs. In DEBUG_INSNs,
35 all lowpart SUBREGs are valid, despite what the machine requires for
36 instructions. */
38 static rtx
39 gen_lowpart_for_debug (machine_mode mode, rtx x)
41 rtx result = gen_lowpart_if_possible (mode, x);
42 if (result)
43 return result;
45 if (GET_MODE (x) != VOIDmode)
46 return gen_rtx_raw_SUBREG (mode, x,
47 subreg_lowpart_offset (mode, GET_MODE (x)));
49 return NULL_RTX;
52 /* Replace auto-increment addressing modes with explicit operations to access
53 the same addresses without modifying the corresponding registers. */
55 static rtx
56 cleanup_auto_inc_dec (rtx src, machine_mode mem_mode ATTRIBUTE_UNUSED)
58 rtx x = src;
60 const RTX_CODE code = GET_CODE (x);
61 int i;
62 const char *fmt;
64 switch (code)
66 case REG:
67 CASE_CONST_ANY:
68 case SYMBOL_REF:
69 case CODE_LABEL:
70 case PC:
71 case SCRATCH:
72 /* SCRATCH must be shared because they represent distinct values. */
73 return x;
74 case CLOBBER:
75 /* Share clobbers of hard registers, but do not share pseudo reg
76 clobbers or clobbers of hard registers that originated as pseudos.
77 This is needed to allow safe register renaming. */
78 if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
79 && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0)))
80 return x;
81 break;
83 case CONST:
84 if (shared_const_p (x))
85 return x;
86 break;
88 case MEM:
89 mem_mode = GET_MODE (x);
90 break;
92 case PRE_INC:
93 case PRE_DEC:
95 gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
96 poly_int64 offset = GET_MODE_SIZE (mem_mode);
97 if (code == PRE_DEC)
98 offset = -offset;
99 return gen_rtx_PLUS (GET_MODE (x),
100 cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
101 gen_int_mode (offset, GET_MODE (x)));
104 case POST_INC:
105 case POST_DEC:
106 case PRE_MODIFY:
107 case POST_MODIFY:
108 return cleanup_auto_inc_dec (code == PRE_MODIFY
109 ? XEXP (x, 1) : XEXP (x, 0),
110 mem_mode);
112 default:
113 break;
116 /* Copy the various flags, fields, and other information. We assume
117 that all fields need copying, and then clear the fields that should
118 not be copied. That is the sensible default behavior, and forces
119 us to explicitly document why we are *not* copying a flag. */
120 x = shallow_copy_rtx (x);
122 /* We do not copy FRAME_RELATED for INSNs. */
123 if (INSN_P (x))
124 RTX_FLAG (x, frame_related) = 0;
126 fmt = GET_RTX_FORMAT (code);
127 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
128 if (fmt[i] == 'e')
129 XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
130 else if (fmt[i] == 'E' || fmt[i] == 'V')
132 int j;
133 XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
134 for (j = 0; j < XVECLEN (x, i); j++)
135 XVECEXP (x, i, j)
136 = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
139 return x;
142 /* Auxiliary data structure for propagate_for_debug_stmt. */
144 struct rtx_subst_pair
146 rtx to;
147 bool adjusted;
148 rtx_insn *insn;
151 /* DATA points to an rtx_subst_pair. Return the value that should be
152 substituted. */
154 static rtx
155 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
157 struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
159 if (!rtx_equal_p (from, old_rtx))
160 return NULL_RTX;
161 if (!pair->adjusted)
163 pair->adjusted = true;
164 pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
165 pair->to = make_compound_operation (pair->to, SET);
166 /* Avoid propagation from growing DEBUG_INSN expressions too much. */
167 int cnt = 0;
168 subrtx_iterator::array_type array;
169 FOR_EACH_SUBRTX (iter, array, pair->to, ALL)
170 if (REG_P (*iter) && ++cnt > 1)
172 rtx dval = make_debug_expr_from_rtl (old_rtx);
173 rtx to = pair->to;
174 if (volatile_insn_p (to))
175 to = gen_rtx_UNKNOWN_VAR_LOC ();
176 /* Emit a debug bind insn. */
177 rtx bind
178 = gen_rtx_VAR_LOCATION (GET_MODE (old_rtx),
179 DEBUG_EXPR_TREE_DECL (dval), to,
180 VAR_INIT_STATUS_INITIALIZED);
181 rtx_insn *bind_insn = emit_debug_insn_before (bind, pair->insn);
182 df_insn_rescan (bind_insn);
183 pair->to = dval;
184 break;
186 return pair->to;
188 return copy_rtx (pair->to);
191 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
192 and LAST, not including INSN, but including LAST. Also stop at the end
193 of THIS_BASIC_BLOCK. */
195 void
196 propagate_for_debug (rtx_insn *insn, rtx_insn *last, rtx dest, rtx src,
197 basic_block this_basic_block)
199 rtx_insn *next, *end = NEXT_INSN (BB_END (this_basic_block));
200 rtx loc;
201 rtx (*saved_rtl_hook_no_emit) (machine_mode, rtx);
203 struct rtx_subst_pair p;
204 p.to = src;
205 p.adjusted = false;
206 p.insn = NEXT_INSN (insn);
208 next = NEXT_INSN (insn);
209 last = NEXT_INSN (last);
210 saved_rtl_hook_no_emit = rtl_hooks.gen_lowpart_no_emit;
211 rtl_hooks.gen_lowpart_no_emit = gen_lowpart_for_debug;
212 while (next != last && next != end)
214 insn = next;
215 next = NEXT_INSN (insn);
216 if (DEBUG_BIND_INSN_P (insn))
218 loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
219 dest, propagate_for_debug_subst, &p);
220 if (loc == INSN_VAR_LOCATION_LOC (insn))
221 continue;
222 if (volatile_insn_p (loc))
223 loc = gen_rtx_UNKNOWN_VAR_LOC ();
224 INSN_VAR_LOCATION_LOC (insn) = loc;
225 df_insn_rescan (insn);
228 rtl_hooks.gen_lowpart_no_emit = saved_rtl_hook_no_emit;
231 /* Initialize DEBUG to an empty list, and clear USED, if given. */
233 void
234 dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
236 debug->used = used;
237 debug->htab = NULL;
238 if (used)
239 bitmap_clear (used);
242 /* Initialize DEBUG to an empty list, and clear USED, if given. Link
243 back to GLOBAL, if given, and bring in used bits from it. */
245 void
246 dead_debug_local_init (struct dead_debug_local *debug, bitmap used,
247 struct dead_debug_global *global)
249 if (!used && global && global->used)
250 used = BITMAP_ALLOC (NULL);
252 debug->head = NULL;
253 debug->global = global;
254 debug->used = used;
255 debug->to_rescan = NULL;
257 if (used)
259 if (global && global->used)
260 bitmap_copy (used, global->used);
261 else
262 bitmap_clear (used);
266 /* Locate the entry for REG in GLOBAL->htab. */
268 static dead_debug_global_entry *
269 dead_debug_global_find (struct dead_debug_global *global, rtx reg)
271 dead_debug_global_entry temp_entry;
272 temp_entry.reg = reg;
274 dead_debug_global_entry *entry = global->htab->find (&temp_entry);
275 gcc_checking_assert (entry && entry->reg == temp_entry.reg);
277 return entry;
280 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
282 static dead_debug_global_entry *
283 dead_debug_global_insert (struct dead_debug_global *global, rtx reg, rtx dtemp)
285 dead_debug_global_entry temp_entry;
286 temp_entry.reg = reg;
287 temp_entry.dtemp = dtemp;
289 if (!global->htab)
290 global->htab = new hash_table<dead_debug_hash_descr> (31);
292 dead_debug_global_entry **slot = global->htab->find_slot (&temp_entry,
293 INSERT);
294 gcc_checking_assert (!*slot);
295 *slot = XNEW (dead_debug_global_entry);
296 **slot = temp_entry;
297 return *slot;
300 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
301 replace it with a USE of the debug temp recorded for it, and
302 return TRUE. Otherwise, just return FALSE.
304 If PTO_RESCAN is given, instead of rescanning modified INSNs right
305 away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
306 is NULL. */
308 static bool
309 dead_debug_global_replace_temp (struct dead_debug_global *global,
310 df_ref use, unsigned int uregno,
311 bitmap *pto_rescan)
313 if (!global || uregno < FIRST_PSEUDO_REGISTER
314 || !global->used
315 || !REG_P (*DF_REF_REAL_LOC (use))
316 || REGNO (*DF_REF_REAL_LOC (use)) != uregno
317 || !bitmap_bit_p (global->used, uregno))
318 return false;
320 dead_debug_global_entry *entry
321 = dead_debug_global_find (global, *DF_REF_REAL_LOC (use));
322 gcc_checking_assert (GET_CODE (entry->reg) == REG
323 && REGNO (entry->reg) == uregno);
325 if (!entry->dtemp)
326 return true;
328 *DF_REF_REAL_LOC (use) = entry->dtemp;
329 if (!pto_rescan)
330 df_insn_rescan (DF_REF_INSN (use));
331 else
333 if (!*pto_rescan)
334 *pto_rescan = BITMAP_ALLOC (NULL);
335 bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
338 return true;
341 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
342 each reset insn. DEBUG is not otherwise modified. If HEAD is
343 DEBUG->head, DEBUG->head will be set to NULL at the end.
344 Otherwise, entries from DEBUG->head that pertain to reset insns
345 will be removed, and only then rescanned. */
347 static void
348 dead_debug_reset_uses (struct dead_debug_local *debug,
349 struct dead_debug_use *head)
351 bool got_head = (debug->head == head);
352 bitmap rescan;
353 struct dead_debug_use **tailp = &debug->head;
354 struct dead_debug_use *cur;
355 bitmap_iterator bi;
356 unsigned int uid;
358 if (got_head)
359 rescan = NULL;
360 else
361 rescan = BITMAP_ALLOC (NULL);
363 while (head)
365 struct dead_debug_use *next = head->next;
366 rtx_insn *insn;
368 insn = DF_REF_INSN (head->use);
369 if (!next || DF_REF_INSN (next->use) != insn)
371 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
372 if (got_head)
373 df_insn_rescan_debug_internal (insn);
374 else
375 bitmap_set_bit (rescan, INSN_UID (insn));
376 if (debug->to_rescan)
377 bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
379 XDELETE (head);
380 head = next;
383 if (got_head)
385 debug->head = NULL;
386 return;
389 while ((cur = *tailp))
390 if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
392 *tailp = cur->next;
393 XDELETE (cur);
395 else
396 tailp = &cur->next;
398 EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
400 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
401 if (insn_info)
402 df_insn_rescan_debug_internal (insn_info->insn);
405 BITMAP_FREE (rescan);
408 /* Promote pending local uses of pseudos in DEBUG to global
409 substitutions. Uses of non-pseudos are left alone for
410 resetting. */
412 static void
413 dead_debug_promote_uses (struct dead_debug_local *debug)
415 for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
416 head; head = *headp)
418 rtx reg = *DF_REF_REAL_LOC (head->use);
419 df_ref ref;
420 dead_debug_global_entry *entry;
422 if (GET_CODE (reg) != REG
423 || REGNO (reg) < FIRST_PSEUDO_REGISTER)
425 headp = &head->next;
426 continue;
429 if (!debug->global->used)
430 debug->global->used = BITMAP_ALLOC (NULL);
432 bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
433 gcc_checking_assert (added);
435 entry = dead_debug_global_insert (debug->global, reg,
436 make_debug_expr_from_rtl (reg));
438 gcc_checking_assert (entry->dtemp);
440 /* Tentatively remove the USE from the list. */
441 *headp = head->next;
443 if (!debug->to_rescan)
444 debug->to_rescan = BITMAP_ALLOC (NULL);
446 for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
447 ref = DF_REF_NEXT_REG (ref))
448 if (DEBUG_INSN_P (DF_REF_INSN (ref)))
450 if (!dead_debug_global_replace_temp (debug->global, ref,
451 REGNO (reg),
452 &debug->to_rescan))
454 rtx_insn *insn = DF_REF_INSN (ref);
455 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
456 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
460 for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
461 ref = DF_REF_NEXT_REG (ref))
462 if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
463 DEBUG_TEMP_BEFORE_WITH_VALUE))
465 rtx bind;
466 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
467 DEBUG_EXPR_TREE_DECL (entry->dtemp),
468 gen_rtx_UNKNOWN_VAR_LOC (),
469 VAR_INIT_STATUS_INITIALIZED);
470 rtx_insn *insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
471 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
474 entry->dtemp = NULL;
475 XDELETE (head);
479 /* Reset all debug insns with pending uses. Release the bitmap in it,
480 unless it is USED. USED must be the same bitmap passed to
481 dead_debug_local_init. */
483 void
484 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
486 if (debug->global)
487 dead_debug_promote_uses (debug);
489 if (debug->used != used)
490 BITMAP_FREE (debug->used);
492 dead_debug_reset_uses (debug, debug->head);
494 if (debug->to_rescan)
496 bitmap_iterator bi;
497 unsigned int uid;
499 EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
501 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
502 if (insn_info)
503 df_insn_rescan (insn_info->insn);
505 BITMAP_FREE (debug->to_rescan);
509 /* Release GLOBAL->used unless it is the same as USED. Release the
510 mapping hash table if it was initialized. */
512 void
513 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
515 if (global->used != used)
516 BITMAP_FREE (global->used);
518 delete global->htab;
519 global->htab = NULL;
522 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
523 the global substitution list. USE must be a dead reference to
524 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
526 void
527 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
529 if (dead_debug_global_replace_temp (debug->global, use, uregno,
530 &debug->to_rescan))
531 return;
533 struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
535 newddu->use = use;
536 newddu->next = debug->head;
537 debug->head = newddu;
539 if (!debug->used)
540 debug->used = BITMAP_ALLOC (NULL);
542 /* ??? If we dealt with split multi-registers below, we should set
543 all registers for the used mode in case of hardware
544 registers. */
545 bitmap_set_bit (debug->used, uregno);
548 /* Like lowpart_subreg, but if a subreg is not valid for machine, force
549 it anyway - for use in debug insns. */
551 static rtx
552 debug_lowpart_subreg (machine_mode outer_mode, rtx expr,
553 machine_mode inner_mode)
555 if (inner_mode == VOIDmode)
556 inner_mode = GET_MODE (expr);
557 poly_int64 offset = subreg_lowpart_offset (outer_mode, inner_mode);
558 rtx ret = simplify_gen_subreg (outer_mode, expr, inner_mode, offset);
559 if (ret)
560 return ret;
561 return gen_rtx_raw_SUBREG (outer_mode, expr, offset);
564 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
565 before or after INSN (depending on WHERE), that binds a (possibly
566 global) debug temp to the widest-mode use of UREGNO, if WHERE is
567 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
568 replace all uses of UREGNO in DEBUG with uses of the debug temp.
569 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
570 is set otherwise. Return the number of debug insns emitted. */
573 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
574 rtx_insn *insn, enum debug_temp_where where)
576 struct dead_debug_use **tailp = &debug->head;
577 struct dead_debug_use *cur;
578 struct dead_debug_use *uses = NULL;
579 struct dead_debug_use **usesp = &uses;
580 rtx reg = NULL_RTX;
581 rtx breg;
582 rtx dval = NULL_RTX;
583 rtx bind;
584 bool global;
586 if (!debug->used)
587 return 0;
589 global = (debug->global && debug->global->used
590 && bitmap_bit_p (debug->global->used, uregno));
592 if (!global && !bitmap_clear_bit (debug->used, uregno))
593 return 0;
595 /* Move all uses of uregno from debug->head to uses, setting mode to
596 the widest referenced mode. */
597 while ((cur = *tailp))
599 if (DF_REF_REGNO (cur->use) == uregno)
601 /* If this loc has been changed e.g. to debug_expr already
602 as part of a multi-register use, just drop it. */
603 if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
605 *tailp = cur->next;
606 XDELETE (cur);
607 continue;
609 *usesp = cur;
610 usesp = &cur->next;
611 *tailp = cur->next;
612 cur->next = NULL;
613 /* "may" rather than "must" because we want (for example)
614 N V4SFs to win over plain V4SF even though N might be 1. */
615 rtx candidate = *DF_REF_REAL_LOC (cur->use);
616 if (!reg
617 || maybe_lt (GET_MODE_BITSIZE (GET_MODE (reg)),
618 GET_MODE_BITSIZE (GET_MODE (candidate))))
619 reg = candidate;
621 else
622 tailp = &(*tailp)->next;
625 /* We may have dangling bits in debug->used for registers that were part
626 of a multi-register use, one component of which has been reset. */
627 if (reg == NULL)
629 gcc_checking_assert (!uses);
630 if (!global)
631 return 0;
634 if (global)
636 if (!reg)
637 reg = regno_reg_rtx[uregno];
638 dead_debug_global_entry *entry
639 = dead_debug_global_find (debug->global, reg);
640 gcc_checking_assert (entry->reg == reg);
641 dval = entry->dtemp;
642 if (!dval)
643 return 0;
646 gcc_checking_assert (uses || global);
648 breg = reg;
649 /* Recover the expression INSN stores in REG. */
650 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
652 rtx set = single_set (insn);
653 rtx dest, src;
655 if (set)
657 dest = SET_DEST (set);
658 src = SET_SRC (set);
659 /* Reset uses if the REG-setting insn is a CALL. Asm in
660 DEBUG_INSN is never useful, we can't emit debug info for
661 that. And for volatile_insn_p, it is actually harmful -
662 DEBUG_INSNs shouldn't have any side-effects. */
663 if (GET_CODE (src) == CALL || GET_CODE (src) == ASM_OPERANDS
664 || volatile_insn_p (src))
665 set = NULL_RTX;
668 /* ??? Should we try to extract it from a PARALLEL? */
669 if (!set)
670 breg = NULL;
671 /* Cool, it's the same REG, we can use SRC. */
672 else if (dest == reg)
673 breg = cleanup_auto_inc_dec (src, VOIDmode);
674 else if (REG_P (dest))
676 /* Hmm... Something's fishy, we should be setting REG here. */
677 if (REGNO (dest) != REGNO (reg))
678 breg = NULL;
679 /* If we're not overwriting all the hardware registers that
680 setting REG in its mode would, we won't know what to bind
681 the debug temp to. ??? We could bind the debug_expr to a
682 CONCAT or PARALLEL with the split multi-registers, and
683 replace them as we found the corresponding sets. */
684 else if (REG_NREGS (reg) != REG_NREGS (dest))
685 breg = NULL;
686 /* Ok, it's the same (hardware) REG, but with a different
687 mode, so SUBREG it. */
688 else
689 breg = debug_lowpart_subreg (GET_MODE (reg),
690 cleanup_auto_inc_dec (src, VOIDmode),
691 GET_MODE (dest));
693 else if (GET_CODE (dest) == SUBREG)
695 /* We should be setting REG here. Lose. */
696 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
697 breg = NULL;
698 /* Lose if we're setting something other than the lowpart of
699 REG. */
700 else if (!subreg_lowpart_p (dest))
701 breg = NULL;
702 /* If we're not overwriting all the hardware registers that
703 setting REG in its mode would, we won't know what to bind
704 the debug temp to. */
705 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
706 && (REG_NREGS (reg)
707 != hard_regno_nregs (REGNO (reg), GET_MODE (dest))))
708 breg = NULL;
709 /* Yay, we can use SRC, just adjust its mode. */
710 else
711 breg = debug_lowpart_subreg (GET_MODE (reg),
712 cleanup_auto_inc_dec (src, VOIDmode),
713 GET_MODE (dest));
715 /* Oh well, we're out of luck. */
716 else
717 breg = NULL;
719 /* We couldn't figure out the value stored in REG, so reset all
720 of its pending debug uses. */
721 if (!breg)
723 dead_debug_reset_uses (debug, uses);
724 return 0;
728 /* If there's a single (debug) use of an otherwise unused REG, and
729 the debug use is not part of a larger expression, then it
730 probably doesn't make sense to introduce a new debug temp. */
731 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
733 rtx_insn *next = DF_REF_INSN (uses->use);
735 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
737 XDELETE (uses);
738 return 0;
742 if (!global)
743 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
744 dval = make_debug_expr_from_rtl (reg);
746 /* Emit a debug bind insn before the insn in which reg dies. */
747 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
748 DEBUG_EXPR_TREE_DECL (dval), breg,
749 VAR_INIT_STATUS_INITIALIZED);
751 if (where == DEBUG_TEMP_AFTER_WITH_REG
752 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
753 bind = emit_debug_insn_after (bind, insn);
754 else
755 bind = emit_debug_insn_before (bind, insn);
756 if (debug->to_rescan == NULL)
757 debug->to_rescan = BITMAP_ALLOC (NULL);
758 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
760 /* Adjust all uses. */
761 while ((cur = uses))
763 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
764 *DF_REF_REAL_LOC (cur->use) = dval;
765 else
766 *DF_REF_REAL_LOC (cur->use)
767 = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
768 GET_MODE (dval));
769 /* ??? Should we simplify subreg of subreg? */
770 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
771 uses = cur->next;
772 XDELETE (cur);
775 return 1;