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   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