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>.
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 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
573 int
dead_debug_insert_temp(struct dead_debug_local * debug,unsigned int uregno,rtx_insn * insn,enum debug_temp_where where)574 dead_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 /* "may" rather than "must" because we want (for example)
615 N V4SFs to win over plain V4SF even though N might be 1. */
616 rtx candidate = *DF_REF_REAL_LOC (cur->use);
617 if (!reg
618 || maybe_lt (GET_MODE_BITSIZE (GET_MODE (reg)),
619 GET_MODE_BITSIZE (GET_MODE (candidate))))
620 reg = candidate;
621 }
622 else
623 tailp = &(*tailp)->next;
624 }
625
626 /* We may have dangling bits in debug->used for registers that were part
627 of a multi-register use, one component of which has been reset. */
628 if (reg == NULL)
629 {
630 gcc_checking_assert (!uses);
631 if (!global)
632 return 0;
633 }
634
635 if (global)
636 {
637 if (!reg)
638 reg = regno_reg_rtx[uregno];
639 dead_debug_global_entry *entry
640 = dead_debug_global_find (debug->global, reg);
641 gcc_checking_assert (entry->reg == reg);
642 dval = entry->dtemp;
643 if (!dval)
644 return 0;
645 }
646
647 gcc_checking_assert (uses || global);
648
649 breg = reg;
650 /* Recover the expression INSN stores in REG. */
651 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
652 {
653 rtx set = single_set (insn);
654 rtx dest, src;
655
656 if (set)
657 {
658 dest = SET_DEST (set);
659 src = SET_SRC (set);
660 /* Reset uses if the REG-setting insn is a CALL. Asm in
661 DEBUG_INSN is never useful, we can't emit debug info for
662 that. And for volatile_insn_p, it is actually harmful -
663 DEBUG_INSNs shouldn't have any side-effects. */
664 if (GET_CODE (src) == CALL || GET_CODE (src) == ASM_OPERANDS
665 || volatile_insn_p (src))
666 set = NULL_RTX;
667 }
668
669 /* ??? Should we try to extract it from a PARALLEL? */
670 if (!set)
671 breg = NULL;
672 /* Cool, it's the same REG, we can use SRC. */
673 else if (dest == reg)
674 breg = cleanup_auto_inc_dec (src, VOIDmode);
675 else if (REG_P (dest))
676 {
677 /* Hmm... Something's fishy, we should be setting REG here. */
678 if (REGNO (dest) != REGNO (reg))
679 breg = NULL;
680 /* If we're not overwriting all the hardware registers that
681 setting REG in its mode would, we won't know what to bind
682 the debug temp to. ??? We could bind the debug_expr to a
683 CONCAT or PARALLEL with the split multi-registers, and
684 replace them as we found the corresponding sets. */
685 else if (REG_NREGS (reg) != REG_NREGS (dest))
686 breg = NULL;
687 /* Ok, it's the same (hardware) REG, but with a different
688 mode, so SUBREG it. */
689 else
690 breg = debug_lowpart_subreg (GET_MODE (reg),
691 cleanup_auto_inc_dec (src, VOIDmode),
692 GET_MODE (dest));
693 }
694 else if (GET_CODE (dest) == SUBREG)
695 {
696 /* We should be setting REG here. Lose. */
697 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
698 breg = NULL;
699 /* Lose if we're setting something other than the lowpart of
700 REG. */
701 else if (!subreg_lowpart_p (dest))
702 breg = NULL;
703 /* If we're not overwriting all the hardware registers that
704 setting REG in its mode would, we won't know what to bind
705 the debug temp to. */
706 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
707 && (REG_NREGS (reg)
708 != hard_regno_nregs (REGNO (reg), GET_MODE (dest))))
709 breg = NULL;
710 /* Yay, we can use SRC, just adjust its mode. */
711 else
712 breg = debug_lowpart_subreg (GET_MODE (reg),
713 cleanup_auto_inc_dec (src, VOIDmode),
714 GET_MODE (dest));
715 }
716 /* Oh well, we're out of luck. */
717 else
718 breg = NULL;
719
720 /* We couldn't figure out the value stored in REG, so reset all
721 of its pending debug uses. */
722 if (!breg)
723 {
724 dead_debug_reset_uses (debug, uses);
725 return 0;
726 }
727 }
728
729 /* If there's a single (debug) use of an otherwise unused REG, and
730 the debug use is not part of a larger expression, then it
731 probably doesn't make sense to introduce a new debug temp. */
732 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
733 {
734 rtx_insn *next = DF_REF_INSN (uses->use);
735
736 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
737 {
738 XDELETE (uses);
739 return 0;
740 }
741 }
742
743 if (!global)
744 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
745 dval = make_debug_expr_from_rtl (reg);
746
747 /* Emit a debug bind insn before the insn in which reg dies. */
748 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
749 DEBUG_EXPR_TREE_DECL (dval), breg,
750 VAR_INIT_STATUS_INITIALIZED);
751
752 if (where == DEBUG_TEMP_AFTER_WITH_REG
753 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
754 bind = emit_debug_insn_after (bind, insn);
755 else
756 bind = emit_debug_insn_before (bind, insn);
757 if (debug->to_rescan == NULL)
758 debug->to_rescan = BITMAP_ALLOC (NULL);
759 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
760
761 /* Adjust all uses. */
762 while ((cur = uses))
763 {
764 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
765 *DF_REF_REAL_LOC (cur->use) = dval;
766 else
767 *DF_REF_REAL_LOC (cur->use)
768 = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
769 GET_MODE (dval));
770 /* ??? Should we simplify subreg of subreg? */
771 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
772 uses = cur->next;
773 XDELETE (cur);
774 }
775
776 return 1;
777 }
778