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