1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010-2014 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>.
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
32 #include "hard-reg-set.h"
38 /* gen_lowpart_no_emit hook implementation for DEBUG_INSNs. In DEBUG_INSNs,
39 all lowpart SUBREGs are valid, despite what the machine requires for
43 gen_lowpart_for_debug (enum machine_mode mode
, rtx x
)
45 rtx result
= gen_lowpart_if_possible (mode
, x
);
49 if (GET_MODE (x
) != VOIDmode
)
50 return gen_rtx_raw_SUBREG (mode
, x
,
51 subreg_lowpart_offset (mode
, GET_MODE (x
)));
56 /* Replace auto-increment addressing modes with explicit operations to access
57 the same addresses without modifying the corresponding registers. */
60 cleanup_auto_inc_dec (rtx src
, enum machine_mode mem_mode ATTRIBUTE_UNUSED
)
64 const RTX_CODE code
= GET_CODE (x
);
77 /* SCRATCH must be shared because they represent distinct values. */
80 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
81 clobbers or clobbers of hard registers that originated as pseudos.
82 This is needed to allow safe register renaming. */
83 if (REG_P (XEXP (x
, 0)) && REGNO (XEXP (x
, 0)) < FIRST_PSEUDO_REGISTER
84 && ORIGINAL_REGNO (XEXP (x
, 0)) == REGNO (XEXP (x
, 0)))
89 if (shared_const_p (x
))
94 mem_mode
= GET_MODE (x
);
99 gcc_assert (mem_mode
!= VOIDmode
&& mem_mode
!= BLKmode
);
100 return gen_rtx_PLUS (GET_MODE (x
),
101 cleanup_auto_inc_dec (XEXP (x
, 0), mem_mode
),
102 gen_int_mode (code
== PRE_INC
103 ? GET_MODE_SIZE (mem_mode
)
104 : -GET_MODE_SIZE (mem_mode
),
111 return cleanup_auto_inc_dec (code
== PRE_MODIFY
112 ? XEXP (x
, 1) : XEXP (x
, 0),
119 /* Copy the various flags, fields, and other information. We assume
120 that all fields need copying, and then clear the fields that should
121 not be copied. That is the sensible default behavior, and forces
122 us to explicitly document why we are *not* copying a flag. */
123 x
= shallow_copy_rtx (x
);
125 /* We do not copy the USED flag, which is used as a mark bit during
126 walks over the RTL. */
127 RTX_FLAG (x
, used
) = 0;
129 /* We do not copy FRAME_RELATED for INSNs. */
131 RTX_FLAG (x
, frame_related
) = 0;
133 fmt
= GET_RTX_FORMAT (code
);
134 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
136 XEXP (x
, i
) = cleanup_auto_inc_dec (XEXP (x
, i
), mem_mode
);
137 else if (fmt
[i
] == 'E' || fmt
[i
] == 'V')
140 XVEC (x
, i
) = rtvec_alloc (XVECLEN (x
, i
));
141 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
143 = cleanup_auto_inc_dec (XVECEXP (src
, i
, j
), mem_mode
);
146 #else /* !AUTO_INC_DEC */
148 #endif /* !AUTO_INC_DEC */
153 /* Auxiliary data structure for propagate_for_debug_stmt. */
155 struct rtx_subst_pair
161 /* DATA points to an rtx_subst_pair. Return the value that should be
165 propagate_for_debug_subst (rtx from
, const_rtx old_rtx
, void *data
)
167 struct rtx_subst_pair
*pair
= (struct rtx_subst_pair
*)data
;
169 if (!rtx_equal_p (from
, old_rtx
))
173 pair
->adjusted
= true;
174 pair
->to
= cleanup_auto_inc_dec (pair
->to
, VOIDmode
);
175 pair
->to
= make_compound_operation (pair
->to
, SET
);
178 return copy_rtx (pair
->to
);
181 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
182 and LAST, not including INSN, but including LAST. Also stop at the end
183 of THIS_BASIC_BLOCK. */
186 propagate_for_debug (rtx_insn
*insn
, rtx_insn
*last
, rtx dest
, rtx src
,
187 basic_block this_basic_block
)
189 rtx_insn
*next
, *end
= NEXT_INSN (BB_END (this_basic_block
));
191 rtx (*saved_rtl_hook_no_emit
) (enum machine_mode
, rtx
);
193 struct rtx_subst_pair p
;
197 next
= NEXT_INSN (insn
);
198 last
= NEXT_INSN (last
);
199 saved_rtl_hook_no_emit
= rtl_hooks
.gen_lowpart_no_emit
;
200 rtl_hooks
.gen_lowpart_no_emit
= gen_lowpart_for_debug
;
201 while (next
!= last
&& next
!= end
)
204 next
= NEXT_INSN (insn
);
205 if (DEBUG_INSN_P (insn
))
207 loc
= simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn
),
208 dest
, propagate_for_debug_subst
, &p
);
209 if (loc
== INSN_VAR_LOCATION_LOC (insn
))
211 INSN_VAR_LOCATION_LOC (insn
) = loc
;
212 df_insn_rescan (insn
);
215 rtl_hooks
.gen_lowpart_no_emit
= saved_rtl_hook_no_emit
;
218 /* Initialize DEBUG to an empty list, and clear USED, if given. */
221 dead_debug_global_init (struct dead_debug_global
*debug
, bitmap used
)
229 /* Initialize DEBUG to an empty list, and clear USED, if given. Link
230 back to GLOBAL, if given, and bring in used bits from it. */
233 dead_debug_local_init (struct dead_debug_local
*debug
, bitmap used
,
234 struct dead_debug_global
*global
)
236 if (!used
&& global
&& global
->used
)
237 used
= BITMAP_ALLOC (NULL
);
240 debug
->global
= global
;
242 debug
->to_rescan
= NULL
;
246 if (global
&& global
->used
)
247 bitmap_copy (used
, global
->used
);
253 /* Locate the entry for REG in GLOBAL->htab. */
255 static dead_debug_global_entry
*
256 dead_debug_global_find (struct dead_debug_global
*global
, rtx reg
)
258 dead_debug_global_entry temp_entry
;
259 temp_entry
.reg
= reg
;
261 dead_debug_global_entry
*entry
= global
->htab
->find (&temp_entry
);
262 gcc_checking_assert (entry
&& entry
->reg
== temp_entry
.reg
);
267 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
269 static dead_debug_global_entry
*
270 dead_debug_global_insert (struct dead_debug_global
*global
, rtx reg
, rtx dtemp
)
272 dead_debug_global_entry temp_entry
;
273 temp_entry
.reg
= reg
;
274 temp_entry
.dtemp
= dtemp
;
277 global
->htab
= new hash_table
<dead_debug_hash_descr
> (31);
279 dead_debug_global_entry
**slot
= global
->htab
->find_slot (&temp_entry
,
281 gcc_checking_assert (!*slot
);
282 *slot
= XNEW (dead_debug_global_entry
);
287 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
288 replace it with with a USE of the debug temp recorded for it, and
289 return TRUE. Otherwise, just return FALSE.
291 If PTO_RESCAN is given, instead of rescanning modified INSNs right
292 away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
296 dead_debug_global_replace_temp (struct dead_debug_global
*global
,
297 df_ref use
, unsigned int uregno
,
300 if (!global
|| uregno
< FIRST_PSEUDO_REGISTER
302 || !REG_P (*DF_REF_REAL_LOC (use
))
303 || REGNO (*DF_REF_REAL_LOC (use
)) != uregno
304 || !bitmap_bit_p (global
->used
, uregno
))
307 dead_debug_global_entry
*entry
308 = dead_debug_global_find (global
, *DF_REF_REAL_LOC (use
));
309 gcc_checking_assert (GET_CODE (entry
->reg
) == REG
310 && REGNO (entry
->reg
) == uregno
);
315 *DF_REF_REAL_LOC (use
) = entry
->dtemp
;
317 df_insn_rescan (DF_REF_INSN (use
));
321 *pto_rescan
= BITMAP_ALLOC (NULL
);
322 bitmap_set_bit (*pto_rescan
, INSN_UID (DF_REF_INSN (use
)));
328 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
329 each reset insn. DEBUG is not otherwise modified. If HEAD is
330 DEBUG->head, DEBUG->head will be set to NULL at the end.
331 Otherwise, entries from DEBUG->head that pertain to reset insns
332 will be removed, and only then rescanned. */
335 dead_debug_reset_uses (struct dead_debug_local
*debug
,
336 struct dead_debug_use
*head
)
338 bool got_head
= (debug
->head
== head
);
340 struct dead_debug_use
**tailp
= &debug
->head
;
341 struct dead_debug_use
*cur
;
348 rescan
= BITMAP_ALLOC (NULL
);
352 struct dead_debug_use
*next
= head
->next
;
355 insn
= DF_REF_INSN (head
->use
);
356 if (!next
|| DF_REF_INSN (next
->use
) != insn
)
358 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
360 df_insn_rescan_debug_internal (insn
);
362 bitmap_set_bit (rescan
, INSN_UID (insn
));
363 if (debug
->to_rescan
)
364 bitmap_clear_bit (debug
->to_rescan
, INSN_UID (insn
));
376 while ((cur
= *tailp
))
377 if (bitmap_bit_p (rescan
, INSN_UID (DF_REF_INSN (cur
->use
))))
385 EXECUTE_IF_SET_IN_BITMAP (rescan
, 0, uid
, bi
)
387 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
389 df_insn_rescan_debug_internal (insn_info
->insn
);
392 BITMAP_FREE (rescan
);
395 /* Promote pending local uses of pseudos in DEBUG to global
396 substitutions. Uses of non-pseudos are left alone for
400 dead_debug_promote_uses (struct dead_debug_local
*debug
)
402 for (struct dead_debug_use
*head
= debug
->head
, **headp
= &debug
->head
;
405 rtx reg
= *DF_REF_REAL_LOC (head
->use
);
407 dead_debug_global_entry
*entry
;
409 if (GET_CODE (reg
) != REG
410 || REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
416 if (!debug
->global
->used
)
417 debug
->global
->used
= BITMAP_ALLOC (NULL
);
419 bool added
= bitmap_set_bit (debug
->global
->used
, REGNO (reg
));
420 gcc_checking_assert (added
);
422 entry
= dead_debug_global_insert (debug
->global
, reg
,
423 make_debug_expr_from_rtl (reg
));
425 gcc_checking_assert (entry
->dtemp
);
427 /* Tentatively remove the USE from the list. */
430 if (!debug
->to_rescan
)
431 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
433 for (ref
= DF_REG_USE_CHAIN (REGNO (reg
)); ref
;
434 ref
= DF_REF_NEXT_REG (ref
))
435 if (DEBUG_INSN_P (DF_REF_INSN (ref
)))
437 if (!dead_debug_global_replace_temp (debug
->global
, ref
,
441 rtx_insn
*insn
= DF_REF_INSN (ref
);
442 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
443 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
447 for (ref
= DF_REG_DEF_CHAIN (REGNO (reg
)); ref
;
448 ref
= DF_REF_NEXT_REG (ref
))
449 if (!dead_debug_insert_temp (debug
, REGNO (reg
), DF_REF_INSN (ref
),
450 DEBUG_TEMP_BEFORE_WITH_VALUE
))
453 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
454 DEBUG_EXPR_TREE_DECL (entry
->dtemp
),
455 gen_rtx_UNKNOWN_VAR_LOC (),
456 VAR_INIT_STATUS_INITIALIZED
);
457 rtx_insn
*insn
= emit_debug_insn_before (bind
, DF_REF_INSN (ref
));
458 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
466 /* Reset all debug insns with pending uses. Release the bitmap in it,
467 unless it is USED. USED must be the same bitmap passed to
468 dead_debug_local_init. */
471 dead_debug_local_finish (struct dead_debug_local
*debug
, bitmap used
)
474 dead_debug_promote_uses (debug
);
476 if (debug
->used
!= used
)
477 BITMAP_FREE (debug
->used
);
479 dead_debug_reset_uses (debug
, debug
->head
);
481 if (debug
->to_rescan
)
486 EXECUTE_IF_SET_IN_BITMAP (debug
->to_rescan
, 0, uid
, bi
)
488 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
490 df_insn_rescan (insn_info
->insn
);
492 BITMAP_FREE (debug
->to_rescan
);
496 /* Release GLOBAL->used unless it is the same as USED. Release the
497 mapping hash table if it was initialized. */
500 dead_debug_global_finish (struct dead_debug_global
*global
, bitmap used
)
502 if (global
->used
!= used
)
503 BITMAP_FREE (global
->used
);
509 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
510 the global substitution list. USE must be a dead reference to
511 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
514 dead_debug_add (struct dead_debug_local
*debug
, df_ref use
, unsigned int uregno
)
516 if (dead_debug_global_replace_temp (debug
->global
, use
, uregno
,
520 struct dead_debug_use
*newddu
= XNEW (struct dead_debug_use
);
523 newddu
->next
= debug
->head
;
524 debug
->head
= newddu
;
527 debug
->used
= BITMAP_ALLOC (NULL
);
529 /* ??? If we dealt with split multi-registers below, we should set
530 all registers for the used mode in case of hardware
532 bitmap_set_bit (debug
->used
, uregno
);
535 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
536 before or after INSN (depending on WHERE), that binds a (possibly
537 global) debug temp to the widest-mode use of UREGNO, if WHERE is
538 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
539 replace all uses of UREGNO in DEBUG with uses of the debug temp.
540 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
541 is set otherwise. Return the number of debug insns emitted. */
544 dead_debug_insert_temp (struct dead_debug_local
*debug
, unsigned int uregno
,
545 rtx_insn
*insn
, enum debug_temp_where where
)
547 struct dead_debug_use
**tailp
= &debug
->head
;
548 struct dead_debug_use
*cur
;
549 struct dead_debug_use
*uses
= NULL
;
550 struct dead_debug_use
**usesp
= &uses
;
560 global
= (debug
->global
&& debug
->global
->used
561 && bitmap_bit_p (debug
->global
->used
, uregno
));
563 if (!global
&& !bitmap_clear_bit (debug
->used
, uregno
))
566 /* Move all uses of uregno from debug->head to uses, setting mode to
567 the widest referenced mode. */
568 while ((cur
= *tailp
))
570 if (DF_REF_REGNO (cur
->use
) == uregno
)
572 /* If this loc has been changed e.g. to debug_expr already
573 as part of a multi-register use, just drop it. */
574 if (!REG_P (*DF_REF_REAL_LOC (cur
->use
)))
585 || (GET_MODE_BITSIZE (GET_MODE (reg
))
586 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)))))
587 reg
= *DF_REF_REAL_LOC (cur
->use
);
590 tailp
= &(*tailp
)->next
;
593 /* We may have dangling bits in debug->used for registers that were part
594 of a multi-register use, one component of which has been reset. */
597 gcc_checking_assert (!uses
);
605 reg
= regno_reg_rtx
[uregno
];
606 dead_debug_global_entry
*entry
607 = dead_debug_global_find (debug
->global
, reg
);
608 gcc_checking_assert (entry
->reg
== reg
);
614 gcc_checking_assert (uses
|| global
);
617 /* Recover the expression INSN stores in REG. */
618 if (where
== DEBUG_TEMP_BEFORE_WITH_VALUE
)
620 rtx set
= single_set (insn
);
625 dest
= SET_DEST (set
);
627 /* Lose if the REG-setting insn is a CALL. */
628 if (GET_CODE (src
) == CALL
)
640 /* ??? Should we try to extract it from a PARALLEL? */
643 /* Cool, it's the same REG, we can use SRC. */
644 else if (dest
== reg
)
645 breg
= cleanup_auto_inc_dec (src
, VOIDmode
);
646 else if (REG_P (dest
))
648 /* Hmm... Something's fishy, we should be setting REG here. */
649 if (REGNO (dest
) != REGNO (reg
))
651 /* If we're not overwriting all the hardware registers that
652 setting REG in its mode would, we won't know what to bind
653 the debug temp to. ??? We could bind the debug_expr to a
654 CONCAT or PARALLEL with the split multi-registers, and
655 replace them as we found the corresponding sets. */
656 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
657 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
658 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
660 /* Ok, it's the same (hardware) REG, but with a different
661 mode, so SUBREG it. */
663 breg
= lowpart_subreg (GET_MODE (reg
),
664 cleanup_auto_inc_dec (src
, VOIDmode
),
667 else if (GET_CODE (dest
) == SUBREG
)
669 /* We should be setting REG here. Lose. */
670 if (REGNO (SUBREG_REG (dest
)) != REGNO (reg
))
672 /* Lose if we're setting something other than the lowpart of
674 else if (!subreg_lowpart_p (dest
))
676 /* If we're not overwriting all the hardware registers that
677 setting REG in its mode would, we won't know what to bind
678 the debug temp to. */
679 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
680 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
681 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
683 /* Yay, we can use SRC, just adjust its mode. */
685 breg
= lowpart_subreg (GET_MODE (reg
),
686 cleanup_auto_inc_dec (src
, VOIDmode
),
689 /* Oh well, we're out of luck. */
693 /* We couldn't figure out the value stored in REG, so reset all
694 of its pending debug uses. */
697 dead_debug_reset_uses (debug
, uses
);
702 /* If there's a single (debug) use of an otherwise unused REG, and
703 the debug use is not part of a larger expression, then it
704 probably doesn't make sense to introduce a new debug temp. */
705 if (where
== DEBUG_TEMP_AFTER_WITH_REG
&& !uses
->next
)
707 rtx_insn
*next
= DF_REF_INSN (uses
->use
);
709 if (DEBUG_INSN_P (next
) && reg
== INSN_VAR_LOCATION_LOC (next
))
717 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
718 dval
= make_debug_expr_from_rtl (reg
);
720 /* Emit a debug bind insn before the insn in which reg dies. */
721 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
722 DEBUG_EXPR_TREE_DECL (dval
), breg
,
723 VAR_INIT_STATUS_INITIALIZED
);
725 if (where
== DEBUG_TEMP_AFTER_WITH_REG
726 || where
== DEBUG_TEMP_AFTER_WITH_REG_FORCE
)
727 bind
= emit_debug_insn_after (bind
, insn
);
729 bind
= emit_debug_insn_before (bind
, insn
);
730 if (debug
->to_rescan
== NULL
)
731 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
732 bitmap_set_bit (debug
->to_rescan
, INSN_UID (bind
));
734 /* Adjust all uses. */
737 if (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)) == GET_MODE (reg
))
738 *DF_REF_REAL_LOC (cur
->use
) = dval
;
740 *DF_REF_REAL_LOC (cur
->use
)
741 = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)), dval
);
742 /* ??? Should we simplify subreg of subreg? */
743 bitmap_set_bit (debug
->to_rescan
, INSN_UID (DF_REF_INSN (cur
->use
)));