gcc/
[official-gcc.git] / gcc / valtrack.c
blob80a0043196935469449731f367bafe5201420b8a
1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010-2015 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 "tm.h"
26 #include "rtl.h"
27 #include "predict.h"
28 #include "basic-block.h"
29 #include "valtrack.h"
30 #include "hard-reg-set.h"
31 #include "function.h"
32 #include "regs.h"
33 #include "emit-rtl.h"
35 /* gen_lowpart_no_emit hook implementation for DEBUG_INSNs. In DEBUG_INSNs,
36 all lowpart SUBREGs are valid, despite what the machine requires for
37 instructions. */
39 static rtx
40 gen_lowpart_for_debug (machine_mode mode, rtx x)
42 rtx result = gen_lowpart_if_possible (mode, x);
43 if (result)
44 return result;
46 if (GET_MODE (x) != VOIDmode)
47 return gen_rtx_raw_SUBREG (mode, x,
48 subreg_lowpart_offset (mode, GET_MODE (x)));
50 return NULL_RTX;
53 /* Replace auto-increment addressing modes with explicit operations to access
54 the same addresses without modifying the corresponding registers. */
56 static rtx
57 cleanup_auto_inc_dec (rtx src, machine_mode mem_mode ATTRIBUTE_UNUSED)
59 rtx x = src;
60 #ifdef AUTO_INC_DEC
61 const RTX_CODE code = GET_CODE (x);
62 int i;
63 const char *fmt;
65 switch (code)
67 case REG:
68 CASE_CONST_ANY:
69 case SYMBOL_REF:
70 case CODE_LABEL:
71 case PC:
72 case CC0:
73 case SCRATCH:
74 /* SCRATCH must be shared because they represent distinct values. */
75 return x;
76 case CLOBBER:
77 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
78 clobbers or clobbers of hard registers that originated as pseudos.
79 This is needed to allow safe register renaming. */
80 if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
81 && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0)))
82 return x;
83 break;
85 case CONST:
86 if (shared_const_p (x))
87 return x;
88 break;
90 case MEM:
91 mem_mode = GET_MODE (x);
92 break;
94 case PRE_INC:
95 case PRE_DEC:
96 gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
97 return gen_rtx_PLUS (GET_MODE (x),
98 cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
99 gen_int_mode (code == PRE_INC
100 ? GET_MODE_SIZE (mem_mode)
101 : -GET_MODE_SIZE (mem_mode),
102 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 the USED flag, which is used as a mark bit during
123 walks over the RTL. */
124 RTX_FLAG (x, used) = 0;
126 /* We do not copy FRAME_RELATED for INSNs. */
127 if (INSN_P (x))
128 RTX_FLAG (x, frame_related) = 0;
130 fmt = GET_RTX_FORMAT (code);
131 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
132 if (fmt[i] == 'e')
133 XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
134 else if (fmt[i] == 'E' || fmt[i] == 'V')
136 int j;
137 XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
138 for (j = 0; j < XVECLEN (x, i); j++)
139 XVECEXP (x, i, j)
140 = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
143 #else /* !AUTO_INC_DEC */
144 x = copy_rtx (x);
145 #endif /* !AUTO_INC_DEC */
147 return x;
150 /* Auxiliary data structure for propagate_for_debug_stmt. */
152 struct rtx_subst_pair
154 rtx to;
155 bool adjusted;
158 /* DATA points to an rtx_subst_pair. Return the value that should be
159 substituted. */
161 static rtx
162 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
164 struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
166 if (!rtx_equal_p (from, old_rtx))
167 return NULL_RTX;
168 if (!pair->adjusted)
170 pair->adjusted = true;
171 pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
172 pair->to = make_compound_operation (pair->to, SET);
173 return pair->to;
175 return copy_rtx (pair->to);
178 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
179 and LAST, not including INSN, but including LAST. Also stop at the end
180 of THIS_BASIC_BLOCK. */
182 void
183 propagate_for_debug (rtx_insn *insn, rtx_insn *last, rtx dest, rtx src,
184 basic_block this_basic_block)
186 rtx_insn *next, *end = NEXT_INSN (BB_END (this_basic_block));
187 rtx loc;
188 rtx (*saved_rtl_hook_no_emit) (machine_mode, rtx);
190 struct rtx_subst_pair p;
191 p.to = src;
192 p.adjusted = false;
194 next = NEXT_INSN (insn);
195 last = NEXT_INSN (last);
196 saved_rtl_hook_no_emit = rtl_hooks.gen_lowpart_no_emit;
197 rtl_hooks.gen_lowpart_no_emit = gen_lowpart_for_debug;
198 while (next != last && next != end)
200 insn = next;
201 next = NEXT_INSN (insn);
202 if (DEBUG_INSN_P (insn))
204 loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
205 dest, propagate_for_debug_subst, &p);
206 if (loc == INSN_VAR_LOCATION_LOC (insn))
207 continue;
208 INSN_VAR_LOCATION_LOC (insn) = loc;
209 df_insn_rescan (insn);
212 rtl_hooks.gen_lowpart_no_emit = saved_rtl_hook_no_emit;
215 /* Initialize DEBUG to an empty list, and clear USED, if given. */
217 void
218 dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
220 debug->used = used;
221 debug->htab = NULL;
222 if (used)
223 bitmap_clear (used);
226 /* Initialize DEBUG to an empty list, and clear USED, if given. Link
227 back to GLOBAL, if given, and bring in used bits from it. */
229 void
230 dead_debug_local_init (struct dead_debug_local *debug, bitmap used,
231 struct dead_debug_global *global)
233 if (!used && global && global->used)
234 used = BITMAP_ALLOC (NULL);
236 debug->head = NULL;
237 debug->global = global;
238 debug->used = used;
239 debug->to_rescan = NULL;
241 if (used)
243 if (global && global->used)
244 bitmap_copy (used, global->used);
245 else
246 bitmap_clear (used);
250 /* Locate the entry for REG in GLOBAL->htab. */
252 static dead_debug_global_entry *
253 dead_debug_global_find (struct dead_debug_global *global, rtx reg)
255 dead_debug_global_entry temp_entry;
256 temp_entry.reg = reg;
258 dead_debug_global_entry *entry = global->htab->find (&temp_entry);
259 gcc_checking_assert (entry && entry->reg == temp_entry.reg);
261 return entry;
264 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
266 static dead_debug_global_entry *
267 dead_debug_global_insert (struct dead_debug_global *global, rtx reg, rtx dtemp)
269 dead_debug_global_entry temp_entry;
270 temp_entry.reg = reg;
271 temp_entry.dtemp = dtemp;
273 if (!global->htab)
274 global->htab = new hash_table<dead_debug_hash_descr> (31);
276 dead_debug_global_entry **slot = global->htab->find_slot (&temp_entry,
277 INSERT);
278 gcc_checking_assert (!*slot);
279 *slot = XNEW (dead_debug_global_entry);
280 **slot = temp_entry;
281 return *slot;
284 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
285 replace it with with a USE of the debug temp recorded for it, and
286 return TRUE. Otherwise, just return FALSE.
288 If PTO_RESCAN is given, instead of rescanning modified INSNs right
289 away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
290 is NULL. */
292 static bool
293 dead_debug_global_replace_temp (struct dead_debug_global *global,
294 df_ref use, unsigned int uregno,
295 bitmap *pto_rescan)
297 if (!global || uregno < FIRST_PSEUDO_REGISTER
298 || !global->used
299 || !REG_P (*DF_REF_REAL_LOC (use))
300 || REGNO (*DF_REF_REAL_LOC (use)) != uregno
301 || !bitmap_bit_p (global->used, uregno))
302 return false;
304 dead_debug_global_entry *entry
305 = dead_debug_global_find (global, *DF_REF_REAL_LOC (use));
306 gcc_checking_assert (GET_CODE (entry->reg) == REG
307 && REGNO (entry->reg) == uregno);
309 if (!entry->dtemp)
310 return true;
312 *DF_REF_REAL_LOC (use) = entry->dtemp;
313 if (!pto_rescan)
314 df_insn_rescan (DF_REF_INSN (use));
315 else
317 if (!*pto_rescan)
318 *pto_rescan = BITMAP_ALLOC (NULL);
319 bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
322 return true;
325 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
326 each reset insn. DEBUG is not otherwise modified. If HEAD is
327 DEBUG->head, DEBUG->head will be set to NULL at the end.
328 Otherwise, entries from DEBUG->head that pertain to reset insns
329 will be removed, and only then rescanned. */
331 static void
332 dead_debug_reset_uses (struct dead_debug_local *debug,
333 struct dead_debug_use *head)
335 bool got_head = (debug->head == head);
336 bitmap rescan;
337 struct dead_debug_use **tailp = &debug->head;
338 struct dead_debug_use *cur;
339 bitmap_iterator bi;
340 unsigned int uid;
342 if (got_head)
343 rescan = NULL;
344 else
345 rescan = BITMAP_ALLOC (NULL);
347 while (head)
349 struct dead_debug_use *next = head->next;
350 rtx_insn *insn;
352 insn = DF_REF_INSN (head->use);
353 if (!next || DF_REF_INSN (next->use) != insn)
355 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
356 if (got_head)
357 df_insn_rescan_debug_internal (insn);
358 else
359 bitmap_set_bit (rescan, INSN_UID (insn));
360 if (debug->to_rescan)
361 bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
363 XDELETE (head);
364 head = next;
367 if (got_head)
369 debug->head = NULL;
370 return;
373 while ((cur = *tailp))
374 if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
376 *tailp = cur->next;
377 XDELETE (cur);
379 else
380 tailp = &cur->next;
382 EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
384 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
385 if (insn_info)
386 df_insn_rescan_debug_internal (insn_info->insn);
389 BITMAP_FREE (rescan);
392 /* Promote pending local uses of pseudos in DEBUG to global
393 substitutions. Uses of non-pseudos are left alone for
394 resetting. */
396 static void
397 dead_debug_promote_uses (struct dead_debug_local *debug)
399 for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
400 head; head = *headp)
402 rtx reg = *DF_REF_REAL_LOC (head->use);
403 df_ref ref;
404 dead_debug_global_entry *entry;
406 if (GET_CODE (reg) != REG
407 || REGNO (reg) < FIRST_PSEUDO_REGISTER)
409 headp = &head->next;
410 continue;
413 if (!debug->global->used)
414 debug->global->used = BITMAP_ALLOC (NULL);
416 bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
417 gcc_checking_assert (added);
419 entry = dead_debug_global_insert (debug->global, reg,
420 make_debug_expr_from_rtl (reg));
422 gcc_checking_assert (entry->dtemp);
424 /* Tentatively remove the USE from the list. */
425 *headp = head->next;
427 if (!debug->to_rescan)
428 debug->to_rescan = BITMAP_ALLOC (NULL);
430 for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
431 ref = DF_REF_NEXT_REG (ref))
432 if (DEBUG_INSN_P (DF_REF_INSN (ref)))
434 if (!dead_debug_global_replace_temp (debug->global, ref,
435 REGNO (reg),
436 &debug->to_rescan))
438 rtx_insn *insn = DF_REF_INSN (ref);
439 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
440 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
444 for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
445 ref = DF_REF_NEXT_REG (ref))
446 if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
447 DEBUG_TEMP_BEFORE_WITH_VALUE))
449 rtx bind;
450 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
451 DEBUG_EXPR_TREE_DECL (entry->dtemp),
452 gen_rtx_UNKNOWN_VAR_LOC (),
453 VAR_INIT_STATUS_INITIALIZED);
454 rtx_insn *insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
455 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
458 entry->dtemp = NULL;
459 XDELETE (head);
463 /* Reset all debug insns with pending uses. Release the bitmap in it,
464 unless it is USED. USED must be the same bitmap passed to
465 dead_debug_local_init. */
467 void
468 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
470 if (debug->global)
471 dead_debug_promote_uses (debug);
473 if (debug->used != used)
474 BITMAP_FREE (debug->used);
476 dead_debug_reset_uses (debug, debug->head);
478 if (debug->to_rescan)
480 bitmap_iterator bi;
481 unsigned int uid;
483 EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
485 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
486 if (insn_info)
487 df_insn_rescan (insn_info->insn);
489 BITMAP_FREE (debug->to_rescan);
493 /* Release GLOBAL->used unless it is the same as USED. Release the
494 mapping hash table if it was initialized. */
496 void
497 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
499 if (global->used != used)
500 BITMAP_FREE (global->used);
502 delete global->htab;
503 global->htab = NULL;
506 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
507 the global substitution list. USE must be a dead reference to
508 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
510 void
511 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
513 if (dead_debug_global_replace_temp (debug->global, use, uregno,
514 &debug->to_rescan))
515 return;
517 struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
519 newddu->use = use;
520 newddu->next = debug->head;
521 debug->head = newddu;
523 if (!debug->used)
524 debug->used = BITMAP_ALLOC (NULL);
526 /* ??? If we dealt with split multi-registers below, we should set
527 all registers for the used mode in case of hardware
528 registers. */
529 bitmap_set_bit (debug->used, uregno);
532 /* Like lowpart_subreg, but if a subreg is not valid for machine, force
533 it anyway - for use in debug insns. */
535 static rtx
536 debug_lowpart_subreg (machine_mode outer_mode, rtx expr,
537 machine_mode inner_mode)
539 if (inner_mode == VOIDmode)
540 inner_mode = GET_MODE (expr);
541 int offset = subreg_lowpart_offset (outer_mode, inner_mode);
542 rtx ret = simplify_gen_subreg (outer_mode, expr, inner_mode, offset);
543 if (ret)
544 return ret;
545 return gen_rtx_raw_SUBREG (outer_mode, expr, offset);
548 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
549 before or after INSN (depending on WHERE), that binds a (possibly
550 global) debug temp to the widest-mode use of UREGNO, if WHERE is
551 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
552 replace all uses of UREGNO in DEBUG with uses of the debug temp.
553 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
554 is set otherwise. Return the number of debug insns emitted. */
557 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
558 rtx_insn *insn, enum debug_temp_where where)
560 struct dead_debug_use **tailp = &debug->head;
561 struct dead_debug_use *cur;
562 struct dead_debug_use *uses = NULL;
563 struct dead_debug_use **usesp = &uses;
564 rtx reg = NULL_RTX;
565 rtx breg;
566 rtx dval = NULL_RTX;
567 rtx bind;
568 bool global;
570 if (!debug->used)
571 return 0;
573 global = (debug->global && debug->global->used
574 && bitmap_bit_p (debug->global->used, uregno));
576 if (!global && !bitmap_clear_bit (debug->used, uregno))
577 return 0;
579 /* Move all uses of uregno from debug->head to uses, setting mode to
580 the widest referenced mode. */
581 while ((cur = *tailp))
583 if (DF_REF_REGNO (cur->use) == uregno)
585 /* If this loc has been changed e.g. to debug_expr already
586 as part of a multi-register use, just drop it. */
587 if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
589 *tailp = cur->next;
590 XDELETE (cur);
591 continue;
593 *usesp = cur;
594 usesp = &cur->next;
595 *tailp = cur->next;
596 cur->next = NULL;
597 if (!reg
598 || (GET_MODE_BITSIZE (GET_MODE (reg))
599 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
600 reg = *DF_REF_REAL_LOC (cur->use);
602 else
603 tailp = &(*tailp)->next;
606 /* We may have dangling bits in debug->used for registers that were part
607 of a multi-register use, one component of which has been reset. */
608 if (reg == NULL)
610 gcc_checking_assert (!uses);
611 if (!global)
612 return 0;
615 if (global)
617 if (!reg)
618 reg = regno_reg_rtx[uregno];
619 dead_debug_global_entry *entry
620 = dead_debug_global_find (debug->global, reg);
621 gcc_checking_assert (entry->reg == reg);
622 dval = entry->dtemp;
623 if (!dval)
624 return 0;
627 gcc_checking_assert (uses || global);
629 breg = reg;
630 /* Recover the expression INSN stores in REG. */
631 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
633 rtx set = single_set (insn);
634 rtx dest, src;
636 if (set)
638 dest = SET_DEST (set);
639 src = SET_SRC (set);
640 /* Lose if the REG-setting insn is a CALL. */
641 if (GET_CODE (src) == CALL)
643 while (uses)
645 cur = uses->next;
646 XDELETE (uses);
647 uses = cur;
649 return 0;
653 /* ??? Should we try to extract it from a PARALLEL? */
654 if (!set)
655 breg = NULL;
656 /* Cool, it's the same REG, we can use SRC. */
657 else if (dest == reg)
658 breg = cleanup_auto_inc_dec (src, VOIDmode);
659 else if (REG_P (dest))
661 /* Hmm... Something's fishy, we should be setting REG here. */
662 if (REGNO (dest) != REGNO (reg))
663 breg = NULL;
664 /* If we're not overwriting all the hardware registers that
665 setting REG in its mode would, we won't know what to bind
666 the debug temp to. ??? We could bind the debug_expr to a
667 CONCAT or PARALLEL with the split multi-registers, and
668 replace them as we found the corresponding sets. */
669 else if (REG_NREGS (reg) != REG_NREGS (dest))
670 breg = NULL;
671 /* Ok, it's the same (hardware) REG, but with a different
672 mode, so SUBREG it. */
673 else
674 breg = debug_lowpart_subreg (GET_MODE (reg),
675 cleanup_auto_inc_dec (src, VOIDmode),
676 GET_MODE (dest));
678 else if (GET_CODE (dest) == SUBREG)
680 /* We should be setting REG here. Lose. */
681 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
682 breg = NULL;
683 /* Lose if we're setting something other than the lowpart of
684 REG. */
685 else if (!subreg_lowpart_p (dest))
686 breg = NULL;
687 /* If we're not overwriting all the hardware registers that
688 setting REG in its mode would, we won't know what to bind
689 the debug temp to. */
690 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
691 && (REG_NREGS (reg)
692 != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
693 breg = NULL;
694 /* Yay, we can use SRC, just adjust its mode. */
695 else
696 breg = debug_lowpart_subreg (GET_MODE (reg),
697 cleanup_auto_inc_dec (src, VOIDmode),
698 GET_MODE (dest));
700 /* Oh well, we're out of luck. */
701 else
702 breg = NULL;
704 /* We couldn't figure out the value stored in REG, so reset all
705 of its pending debug uses. */
706 if (!breg)
708 dead_debug_reset_uses (debug, uses);
709 return 0;
713 /* If there's a single (debug) use of an otherwise unused REG, and
714 the debug use is not part of a larger expression, then it
715 probably doesn't make sense to introduce a new debug temp. */
716 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
718 rtx_insn *next = DF_REF_INSN (uses->use);
720 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
722 XDELETE (uses);
723 return 0;
727 if (!global)
728 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
729 dval = make_debug_expr_from_rtl (reg);
731 /* Emit a debug bind insn before the insn in which reg dies. */
732 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
733 DEBUG_EXPR_TREE_DECL (dval), breg,
734 VAR_INIT_STATUS_INITIALIZED);
736 if (where == DEBUG_TEMP_AFTER_WITH_REG
737 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
738 bind = emit_debug_insn_after (bind, insn);
739 else
740 bind = emit_debug_insn_before (bind, insn);
741 if (debug->to_rescan == NULL)
742 debug->to_rescan = BITMAP_ALLOC (NULL);
743 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
745 /* Adjust all uses. */
746 while ((cur = uses))
748 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
749 *DF_REF_REAL_LOC (cur->use) = dval;
750 else
751 *DF_REF_REAL_LOC (cur->use)
752 = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
753 GET_MODE (dval));
754 /* ??? Should we simplify subreg of subreg? */
755 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
756 uses = cur->next;
757 XDELETE (cur);
760 return 1;