1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010-2022 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 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;
82
83 case CONST:
84 if (shared_const_p (x))
85 return x;
86 break;
87
88 case MEM:
89 mem_mode = GET_MODE (x);
90 break;
91
92 case PRE_INC:
93 case PRE_DEC:
94 {
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)));
102 }
103
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);
111
112 default:
113 break;
114 }
115
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);
121
122 /* We do not copy FRAME_RELATED for INSNs. */
123 if (INSN_P (x))
124 RTX_FLAG (x, frame_related) = 0;
125
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')
131 {
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);
137 }
138
139 return x;
140 }
141
142 /* Auxiliary data structure for propagate_for_debug_stmt. */
143
144 struct rtx_subst_pair
145 {
146 rtx to;
147 bool adjusted;
148 rtx_insn *insn;
149 };
150
151 /* DATA points to an rtx_subst_pair. Return the value that should be
152 substituted. */
153
154 static rtx
propagate_for_debug_subst(rtx from,const_rtx old_rtx,void * data)155 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
156 {
157 struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
158
159 if (!rtx_equal_p (from, old_rtx))
160 return NULL_RTX;
161 if (!pair->adjusted)
162 {
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)
171 {
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;
185 }
186 return pair->to;
187 }
188 return copy_rtx (pair->to);
189 }
190
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. */
194
195 void
propagate_for_debug(rtx_insn * insn,rtx_insn * last,rtx dest,rtx src,basic_block this_basic_block)196 propagate_for_debug (rtx_insn *insn, rtx_insn *last, rtx dest, rtx src,
197 basic_block this_basic_block)
198 {
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);
202
203 struct rtx_subst_pair p;
204 p.to = src;
205 p.adjusted = false;
206 p.insn = NEXT_INSN (insn);
207
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)
213 {
214 insn = next;
215 next = NEXT_INSN (insn);
216 if (DEBUG_BIND_INSN_P (insn))
217 {
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);
226 }
227 }
228 rtl_hooks.gen_lowpart_no_emit = saved_rtl_hook_no_emit;
229 }
230
231 /* Initialize DEBUG to an empty list, and clear USED, if given. */
232
233 void
dead_debug_global_init(struct dead_debug_global * debug,bitmap used)234 dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
235 {
236 debug->used = used;
237 debug->htab = NULL;
238 if (used)
239 bitmap_clear (used);
240 }
241
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. */
244
245 void
dead_debug_local_init(struct dead_debug_local * debug,bitmap used,struct dead_debug_global * global)246 dead_debug_local_init (struct dead_debug_local *debug, bitmap used,
247 struct dead_debug_global *global)
248 {
249 if (!used && global && global->used)
250 used = BITMAP_ALLOC (NULL);
251
252 debug->head = NULL;
253 debug->global = global;
254 debug->used = used;
255 debug->to_rescan = NULL;
256
257 if (used)
258 {
259 if (global && global->used)
260 bitmap_copy (used, global->used);
261 else
262 bitmap_clear (used);
263 }
264 }
265
266 /* Locate the entry for REG in GLOBAL->htab. */
267
268 static dead_debug_global_entry *
dead_debug_global_find(struct dead_debug_global * global,rtx reg)269 dead_debug_global_find (struct dead_debug_global *global, rtx reg)
270 {
271 dead_debug_global_entry temp_entry;
272 temp_entry.reg = reg;
273
274 dead_debug_global_entry *entry = global->htab->find (&temp_entry);
275 gcc_checking_assert (entry && entry->reg == temp_entry.reg);
276
277 return entry;
278 }
279
280 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
281
282 static dead_debug_global_entry *
dead_debug_global_insert(struct dead_debug_global * global,rtx reg,rtx dtemp)283 dead_debug_global_insert (struct dead_debug_global *global, rtx reg, rtx dtemp)
284 {
285 dead_debug_global_entry temp_entry;
286 temp_entry.reg = reg;
287 temp_entry.dtemp = dtemp;
288
289 if (!global->htab)
290 global->htab = new hash_table<dead_debug_hash_descr> (31);
291
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;
298 }
299
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.
303
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. */
307
308 static bool
dead_debug_global_replace_temp(struct dead_debug_global * global,df_ref use,unsigned int uregno,bitmap * pto_rescan)309 dead_debug_global_replace_temp (struct dead_debug_global *global,
310 df_ref use, unsigned int uregno,
311 bitmap *pto_rescan)
312 {
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;
319
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);
324
325 if (!entry->dtemp)
326 return true;
327
328 *DF_REF_REAL_LOC (use) = entry->dtemp;
329 if (!pto_rescan)
330 df_insn_rescan (DF_REF_INSN (use));
331 else
332 {
333 if (!*pto_rescan)
334 *pto_rescan = BITMAP_ALLOC (NULL);
335 bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
336 }
337
338 return true;
339 }
340
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. */
346
347 static void
dead_debug_reset_uses(struct dead_debug_local * debug,struct dead_debug_use * head)348 dead_debug_reset_uses (struct dead_debug_local *debug,
349 struct dead_debug_use *head)
350 {
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;
357
358 if (got_head)
359 rescan = NULL;
360 else
361 rescan = BITMAP_ALLOC (NULL);
362
363 while (head)
364 {
365 struct dead_debug_use *next = head->next;
366 rtx_insn *insn;
367
368 insn = DF_REF_INSN (head->use);
369 if (!next || DF_REF_INSN (next->use) != insn)
370 {
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));
378 }
379 XDELETE (head);
380 head = next;
381 }
382
383 if (got_head)
384 {
385 debug->head = NULL;
386 return;
387 }
388
389 while ((cur = *tailp))
390 if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
391 {
392 *tailp = cur->next;
393 XDELETE (cur);
394 }
395 else
396 tailp = &cur->next;
397
398 EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
399 {
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);
403 }
404
405 BITMAP_FREE (rescan);
406 }
407
408 /* Promote pending local uses of pseudos in DEBUG to global
409 substitutions. Uses of non-pseudos are left alone for
410 resetting. */
411
412 static void
dead_debug_promote_uses(struct dead_debug_local * debug)413 dead_debug_promote_uses (struct dead_debug_local *debug)
414 {
415 for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
416 head; head = *headp)
417 {
418 rtx reg = *DF_REF_REAL_LOC (head->use);
419 df_ref ref;
420 dead_debug_global_entry *entry;
421
422 if (GET_CODE (reg) != REG
423 || REGNO (reg) < FIRST_PSEUDO_REGISTER)
424 {
425 headp = &head->next;
426 continue;
427 }
428
429 if (!debug->global->used)
430 debug->global->used = BITMAP_ALLOC (NULL);
431
432 bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
433 gcc_checking_assert (added);
434
435 entry = dead_debug_global_insert (debug->global, reg,
436 make_debug_expr_from_rtl (reg));
437
438 gcc_checking_assert (entry->dtemp);
439
440 /* Tentatively remove the USE from the list. */
441 *headp = head->next;
442
443 if (!debug->to_rescan)
444 debug->to_rescan = BITMAP_ALLOC (NULL);
445
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)))
449 {
450 if (!dead_debug_global_replace_temp (debug->global, ref,
451 REGNO (reg),
452 &debug->to_rescan))
453 {
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));
457 }
458 }
459
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))
464 {
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));
472 }
473
474 entry->dtemp = NULL;
475 XDELETE (head);
476 }
477 }
478
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. */
482
483 void
dead_debug_local_finish(struct dead_debug_local * debug,bitmap used)484 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
485 {
486 if (debug->global)
487 dead_debug_promote_uses (debug);
488
489 if (debug->used != used)
490 BITMAP_FREE (debug->used);
491
492 dead_debug_reset_uses (debug, debug->head);
493
494 if (debug->to_rescan)
495 {
496 bitmap_iterator bi;
497 unsigned int uid;
498
499 EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
500 {
501 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
502 if (insn_info)
503 df_insn_rescan (insn_info->insn);
504 }
505 BITMAP_FREE (debug->to_rescan);
506 }
507 }
508
509 /* Release GLOBAL->used unless it is the same as USED. Release the
510 mapping hash table if it was initialized. */
511
512 void
dead_debug_global_finish(struct dead_debug_global * global,bitmap used)513 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
514 {
515 if (global->used != used)
516 BITMAP_FREE (global->used);
517
518 delete global->htab;
519 global->htab = NULL;
520 }
521
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. */
525
526 void
dead_debug_add(struct dead_debug_local * debug,df_ref use,unsigned int uregno)527 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
528 {
529 if (dead_debug_global_replace_temp (debug->global, use, uregno,
530 &debug->to_rescan))
531 return;
532
533 struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
534
535 newddu->use = use;
536 newddu->next = debug->head;
537 debug->head = newddu;
538
539 if (!debug->used)
540 debug->used = BITMAP_ALLOC (NULL);
541
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);
546 }
547
548 /* Like lowpart_subreg, but if a subreg is not valid for machine, force
549 it anyway - for use in debug insns. */
550
551 static rtx
debug_lowpart_subreg(machine_mode outer_mode,rtx expr,machine_mode inner_mode)552 debug_lowpart_subreg (machine_mode outer_mode, rtx expr,
553 machine_mode inner_mode)
554 {
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 if (GET_MODE (expr) != VOIDmode)
562 return gen_rtx_raw_SUBREG (outer_mode, expr, offset);
563 return NULL_RTX;
564 }
565
566 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
567 before or after INSN (depending on WHERE), that binds a (possibly
568 global) debug temp to the widest-mode use of UREGNO, if WHERE is
569 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
570 replace all uses of UREGNO in DEBUG with uses of the debug temp.
571 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
572 is set otherwise. Return the number of debug insns emitted. */
573
574 int
dead_debug_insert_temp(struct dead_debug_local * debug,unsigned int uregno,rtx_insn * insn,enum debug_temp_where where)575 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
576 rtx_insn *insn, enum debug_temp_where where)
577 {
578 struct dead_debug_use **tailp = &debug->head;
579 struct dead_debug_use *cur;
580 struct dead_debug_use *uses = NULL;
581 struct dead_debug_use **usesp = &uses;
582 rtx reg = NULL_RTX;
583 rtx breg;
584 rtx dval = NULL_RTX;
585 rtx bind;
586 bool global;
587
588 if (!debug->used)
589 return 0;
590
591 global = (debug->global && debug->global->used
592 && bitmap_bit_p (debug->global->used, uregno));
593
594 if (!global && !bitmap_clear_bit (debug->used, uregno))
595 return 0;
596
597 /* Move all uses of uregno from debug->head to uses, setting mode to
598 the widest referenced mode. */
599 while ((cur = *tailp))
600 {
601 if (DF_REF_REGNO (cur->use) == uregno)
602 {
603 /* If this loc has been changed e.g. to debug_expr already
604 as part of a multi-register use, just drop it. */
605 if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
606 {
607 *tailp = cur->next;
608 XDELETE (cur);
609 continue;
610 }
611 *usesp = cur;
612 usesp = &cur->next;
613 *tailp = cur->next;
614 cur->next = NULL;
615 /* "may" rather than "must" because we want (for example)
616 N V4SFs to win over plain V4SF even though N might be 1. */
617 rtx candidate = *DF_REF_REAL_LOC (cur->use);
618 if (!reg
619 || maybe_lt (GET_MODE_BITSIZE (GET_MODE (reg)),
620 GET_MODE_BITSIZE (GET_MODE (candidate))))
621 reg = candidate;
622 }
623 else
624 tailp = &(*tailp)->next;
625 }
626
627 /* We may have dangling bits in debug->used for registers that were part
628 of a multi-register use, one component of which has been reset. */
629 if (reg == NULL)
630 {
631 gcc_checking_assert (!uses);
632 if (!global)
633 return 0;
634 }
635
636 if (global)
637 {
638 if (!reg)
639 reg = regno_reg_rtx[uregno];
640 dead_debug_global_entry *entry
641 = dead_debug_global_find (debug->global, reg);
642 gcc_checking_assert (entry->reg == reg);
643 dval = entry->dtemp;
644 if (!dval)
645 return 0;
646 }
647
648 gcc_checking_assert (uses || global);
649
650 breg = reg;
651 /* Recover the expression INSN stores in REG. */
652 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
653 {
654 rtx set = single_set (insn);
655 rtx dest, src;
656
657 if (set)
658 {
659 dest = SET_DEST (set);
660 src = SET_SRC (set);
661 /* Reset uses if the REG-setting insn is a CALL. Asm in
662 DEBUG_INSN is never useful, we can't emit debug info for
663 that. And for volatile_insn_p, it is actually harmful -
664 DEBUG_INSNs shouldn't have any side-effects. */
665 if (GET_CODE (src) == CALL || GET_CODE (src) == ASM_OPERANDS
666 || volatile_insn_p (src))
667 set = NULL_RTX;
668 }
669
670 /* ??? Should we try to extract it from a PARALLEL? */
671 if (!set)
672 breg = NULL;
673 /* Cool, it's the same REG, we can use SRC. */
674 else if (dest == reg)
675 breg = cleanup_auto_inc_dec (src, VOIDmode);
676 else if (REG_P (dest))
677 {
678 /* Hmm... Something's fishy, we should be setting REG here. */
679 if (REGNO (dest) != REGNO (reg))
680 breg = NULL;
681 /* If we're not overwriting all the hardware registers that
682 setting REG in its mode would, we won't know what to bind
683 the debug temp to. ??? We could bind the debug_expr to a
684 CONCAT or PARALLEL with the split multi-registers, and
685 replace them as we found the corresponding sets. */
686 else if (REG_NREGS (reg) != REG_NREGS (dest))
687 breg = NULL;
688 /* Ok, it's the same (hardware) REG, but with a different
689 mode, so SUBREG it. */
690 else
691 breg = debug_lowpart_subreg (GET_MODE (reg),
692 cleanup_auto_inc_dec (src, VOIDmode),
693 GET_MODE (dest));
694 }
695 else if (GET_CODE (dest) == SUBREG)
696 {
697 /* We should be setting REG here. Lose. */
698 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
699 breg = NULL;
700 /* Lose if we're setting something other than the lowpart of
701 REG. */
702 else if (!subreg_lowpart_p (dest))
703 breg = NULL;
704 /* If we're not overwriting all the hardware registers that
705 setting REG in its mode would, we won't know what to bind
706 the debug temp to. */
707 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
708 && (REG_NREGS (reg)
709 != hard_regno_nregs (REGNO (reg), GET_MODE (dest))))
710 breg = NULL;
711 /* Yay, we can use SRC, just adjust its mode. */
712 else
713 breg = debug_lowpart_subreg (GET_MODE (reg),
714 cleanup_auto_inc_dec (src, VOIDmode),
715 GET_MODE (dest));
716 }
717 /* Oh well, we're out of luck. */
718 else
719 breg = NULL;
720
721 /* We couldn't figure out the value stored in REG, so reset all
722 of its pending debug uses. */
723 if (!breg)
724 {
725 dead_debug_reset_uses (debug, uses);
726 return 0;
727 }
728 }
729
730 /* If there's a single (debug) use of an otherwise unused REG, and
731 the debug use is not part of a larger expression, then it
732 probably doesn't make sense to introduce a new debug temp. */
733 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
734 {
735 rtx_insn *next = DF_REF_INSN (uses->use);
736
737 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
738 {
739 XDELETE (uses);
740 return 0;
741 }
742 }
743
744 if (!global)
745 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
746 dval = make_debug_expr_from_rtl (reg);
747
748 /* Emit a debug bind insn before the insn in which reg dies. */
749 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
750 DEBUG_EXPR_TREE_DECL (dval), breg,
751 VAR_INIT_STATUS_INITIALIZED);
752
753 if (where == DEBUG_TEMP_AFTER_WITH_REG
754 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
755 bind = emit_debug_insn_after (bind, insn);
756 else
757 bind = emit_debug_insn_before (bind, insn);
758 if (debug->to_rescan == NULL)
759 debug->to_rescan = BITMAP_ALLOC (NULL);
760 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
761
762 /* Adjust all uses. */
763 while ((cur = uses))
764 {
765 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
766 *DF_REF_REAL_LOC (cur->use) = dval;
767 else
768 *DF_REF_REAL_LOC (cur->use)
769 = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
770 GET_MODE (dval));
771 /* ??? Should we simplify subreg of subreg? */
772 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
773 uses = cur->next;
774 XDELETE (cur);
775 }
776
777 return 1;
778 }
779