1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010-2020 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>.
5
6 This file is part of GCC.
7
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.
12
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.
17
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/>. */
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
38 static rtx
gen_lowpart_for_debug(machine_mode mode,rtx x)39 gen_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
55 static rtx
cleanup_auto_inc_dec(rtx src,machine_mode mem_mode ATTRIBUTE_UNUSED)56 cleanup_auto_inc_dec (rtx src, machine_mode mem_mode ATTRIBUTE_UNUSED)
57 {
58 rtx x = src;
59
60 const RTX_CODE code = GET_CODE (x);
61 int i;
62 const char *fmt;
63
64 switch (code)
65 {
66 case REG:
67 CASE_CONST_ANY:
68 case SYMBOL_REF:
69 case CODE_LABEL:
70 case PC:
71 case CC0:
72 case SCRATCH:
73 /* SCRATCH must be shared because they represent distinct values. */
74 return x;
75 case CLOBBER:
76 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
77 clobbers or clobbers of hard registers that originated as pseudos.
78 This is needed to allow safe register renaming. */
79 if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
80 && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0)))
81 return x;
82 break;
83
84 case CONST:
85 if (shared_const_p (x))
86 return x;
87 break;
88
89 case MEM:
90 mem_mode = GET_MODE (x);
91 break;
92
93 case PRE_INC:
94 case PRE_DEC:
95 {
96 gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
97 poly_int64 offset = GET_MODE_SIZE (mem_mode);
98 if (code == PRE_DEC)
99 offset = -offset;
100 return gen_rtx_PLUS (GET_MODE (x),
101 cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
102 gen_int_mode (offset, GET_MODE (x)));
103 }
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
145 struct 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
155 static rtx
propagate_for_debug_subst(rtx from,const_rtx old_rtx,void * data)156 propagate_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
196 void
propagate_for_debug(rtx_insn * insn,rtx_insn * last,rtx dest,rtx src,basic_block this_basic_block)197 propagate_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
234 void
dead_debug_global_init(struct dead_debug_global * debug,bitmap used)235 dead_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
246 void
dead_debug_local_init(struct dead_debug_local * debug,bitmap used,struct dead_debug_global * global)247 dead_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
269 static dead_debug_global_entry *
dead_debug_global_find(struct dead_debug_global * global,rtx reg)270 dead_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
283 static dead_debug_global_entry *
dead_debug_global_insert(struct dead_debug_global * global,rtx reg,rtx dtemp)284 dead_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
309 static bool
dead_debug_global_replace_temp(struct dead_debug_global * global,df_ref use,unsigned int uregno,bitmap * pto_rescan)310 dead_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
348 static void
dead_debug_reset_uses(struct dead_debug_local * debug,struct dead_debug_use * head)349 dead_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
413 static void
dead_debug_promote_uses(struct dead_debug_local * debug)414 dead_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
484 void
dead_debug_local_finish(struct dead_debug_local * debug,bitmap used)485 dead_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
513 void
dead_debug_global_finish(struct dead_debug_global * global,bitmap used)514 dead_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
527 void
dead_debug_add(struct dead_debug_local * debug,df_ref use,unsigned int uregno)528 dead_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
552 static rtx
debug_lowpart_subreg(machine_mode outer_mode,rtx expr,machine_mode inner_mode)553 debug_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 poly_int64 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 if (GET_MODE (expr) != VOIDmode)
563 return gen_rtx_raw_SUBREG (outer_mode, expr, offset);
564 return NULL_RTX;
565 }
566
567 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
568 before or after INSN (depending on WHERE), that binds a (possibly
569 global) debug temp to the widest-mode use of UREGNO, if WHERE is
570 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
571 replace all uses of UREGNO in DEBUG with uses of the debug temp.
572 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
573 is set otherwise. Return the number of debug insns emitted. */
574
575 int
dead_debug_insert_temp(struct dead_debug_local * debug,unsigned int uregno,rtx_insn * insn,enum debug_temp_where where)576 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
577 rtx_insn *insn, enum debug_temp_where where)
578 {
579 struct dead_debug_use **tailp = &debug->head;
580 struct dead_debug_use *cur;
581 struct dead_debug_use *uses = NULL;
582 struct dead_debug_use **usesp = &uses;
583 rtx reg = NULL_RTX;
584 rtx breg;
585 rtx dval = NULL_RTX;
586 rtx bind;
587 bool global;
588
589 if (!debug->used)
590 return 0;
591
592 global = (debug->global && debug->global->used
593 && bitmap_bit_p (debug->global->used, uregno));
594
595 if (!global && !bitmap_clear_bit (debug->used, uregno))
596 return 0;
597
598 /* Move all uses of uregno from debug->head to uses, setting mode to
599 the widest referenced mode. */
600 while ((cur = *tailp))
601 {
602 if (DF_REF_REGNO (cur->use) == uregno)
603 {
604 /* If this loc has been changed e.g. to debug_expr already
605 as part of a multi-register use, just drop it. */
606 if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
607 {
608 *tailp = cur->next;
609 XDELETE (cur);
610 continue;
611 }
612 *usesp = cur;
613 usesp = &cur->next;
614 *tailp = cur->next;
615 cur->next = NULL;
616 /* "may" rather than "must" because we want (for example)
617 N V4SFs to win over plain V4SF even though N might be 1. */
618 rtx candidate = *DF_REF_REAL_LOC (cur->use);
619 if (!reg
620 || maybe_lt (GET_MODE_BITSIZE (GET_MODE (reg)),
621 GET_MODE_BITSIZE (GET_MODE (candidate))))
622 reg = candidate;
623 }
624 else
625 tailp = &(*tailp)->next;
626 }
627
628 /* We may have dangling bits in debug->used for registers that were part
629 of a multi-register use, one component of which has been reset. */
630 if (reg == NULL)
631 {
632 gcc_checking_assert (!uses);
633 if (!global)
634 return 0;
635 }
636
637 if (global)
638 {
639 if (!reg)
640 reg = regno_reg_rtx[uregno];
641 dead_debug_global_entry *entry
642 = dead_debug_global_find (debug->global, reg);
643 gcc_checking_assert (entry->reg == reg);
644 dval = entry->dtemp;
645 if (!dval)
646 return 0;
647 }
648
649 gcc_checking_assert (uses || global);
650
651 breg = reg;
652 /* Recover the expression INSN stores in REG. */
653 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
654 {
655 rtx set = single_set (insn);
656 rtx dest, src;
657
658 if (set)
659 {
660 dest = SET_DEST (set);
661 src = SET_SRC (set);
662 /* Reset uses if the REG-setting insn is a CALL. Asm in
663 DEBUG_INSN is never useful, we can't emit debug info for
664 that. And for volatile_insn_p, it is actually harmful -
665 DEBUG_INSNs shouldn't have any side-effects. */
666 if (GET_CODE (src) == CALL || GET_CODE (src) == ASM_OPERANDS
667 || volatile_insn_p (src))
668 set = NULL_RTX;
669 }
670
671 /* ??? Should we try to extract it from a PARALLEL? */
672 if (!set)
673 breg = NULL;
674 /* Cool, it's the same REG, we can use SRC. */
675 else if (dest == reg)
676 breg = cleanup_auto_inc_dec (src, VOIDmode);
677 else if (REG_P (dest))
678 {
679 /* Hmm... Something's fishy, we should be setting REG here. */
680 if (REGNO (dest) != REGNO (reg))
681 breg = NULL;
682 /* If we're not overwriting all the hardware registers that
683 setting REG in its mode would, we won't know what to bind
684 the debug temp to. ??? We could bind the debug_expr to a
685 CONCAT or PARALLEL with the split multi-registers, and
686 replace them as we found the corresponding sets. */
687 else if (REG_NREGS (reg) != REG_NREGS (dest))
688 breg = NULL;
689 /* Ok, it's the same (hardware) REG, but with a different
690 mode, so SUBREG it. */
691 else
692 breg = debug_lowpart_subreg (GET_MODE (reg),
693 cleanup_auto_inc_dec (src, VOIDmode),
694 GET_MODE (dest));
695 }
696 else if (GET_CODE (dest) == SUBREG)
697 {
698 /* We should be setting REG here. Lose. */
699 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
700 breg = NULL;
701 /* Lose if we're setting something other than the lowpart of
702 REG. */
703 else if (!subreg_lowpart_p (dest))
704 breg = NULL;
705 /* If we're not overwriting all the hardware registers that
706 setting REG in its mode would, we won't know what to bind
707 the debug temp to. */
708 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
709 && (REG_NREGS (reg)
710 != hard_regno_nregs (REGNO (reg), GET_MODE (dest))))
711 breg = NULL;
712 /* Yay, we can use SRC, just adjust its mode. */
713 else
714 breg = debug_lowpart_subreg (GET_MODE (reg),
715 cleanup_auto_inc_dec (src, VOIDmode),
716 GET_MODE (dest));
717 }
718 /* Oh well, we're out of luck. */
719 else
720 breg = NULL;
721
722 /* We couldn't figure out the value stored in REG, so reset all
723 of its pending debug uses. */
724 if (!breg)
725 {
726 dead_debug_reset_uses (debug, uses);
727 return 0;
728 }
729 }
730
731 /* If there's a single (debug) use of an otherwise unused REG, and
732 the debug use is not part of a larger expression, then it
733 probably doesn't make sense to introduce a new debug temp. */
734 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
735 {
736 rtx_insn *next = DF_REF_INSN (uses->use);
737
738 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
739 {
740 XDELETE (uses);
741 return 0;
742 }
743 }
744
745 if (!global)
746 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
747 dval = make_debug_expr_from_rtl (reg);
748
749 /* Emit a debug bind insn before the insn in which reg dies. */
750 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
751 DEBUG_EXPR_TREE_DECL (dval), breg,
752 VAR_INIT_STATUS_INITIALIZED);
753
754 if (where == DEBUG_TEMP_AFTER_WITH_REG
755 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
756 bind = emit_debug_insn_after (bind, insn);
757 else
758 bind = emit_debug_insn_before (bind, insn);
759 if (debug->to_rescan == NULL)
760 debug->to_rescan = BITMAP_ALLOC (NULL);
761 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
762
763 /* Adjust all uses. */
764 while ((cur = uses))
765 {
766 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
767 *DF_REF_REAL_LOC (cur->use) = dval;
768 else
769 *DF_REF_REAL_LOC (cur->use)
770 = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
771 GET_MODE (dval));
772 /* ??? Should we simplify subreg of subreg? */
773 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
774 uses = cur->next;
775 XDELETE (cur);
776 }
777
778 return 1;
779 }
780