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"
28 #include "basic-block.h"
34 #include "hard-reg-set.h"
40 /* gen_lowpart_no_emit hook implementation for DEBUG_INSNs. In DEBUG_INSNs,
41 all lowpart SUBREGs are valid, despite what the machine requires for
45 gen_lowpart_for_debug (enum machine_mode mode
, rtx x
)
47 rtx result
= gen_lowpart_if_possible (mode
, x
);
51 if (GET_MODE (x
) != VOIDmode
)
52 return gen_rtx_raw_SUBREG (mode
, x
,
53 subreg_lowpart_offset (mode
, GET_MODE (x
)));
58 /* Replace auto-increment addressing modes with explicit operations to access
59 the same addresses without modifying the corresponding registers. */
62 cleanup_auto_inc_dec (rtx src
, enum machine_mode mem_mode ATTRIBUTE_UNUSED
)
66 const RTX_CODE code
= GET_CODE (x
);
79 /* SCRATCH must be shared because they represent distinct values. */
82 /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
83 clobbers or clobbers of hard registers that originated as pseudos.
84 This is needed to allow safe register renaming. */
85 if (REG_P (XEXP (x
, 0)) && REGNO (XEXP (x
, 0)) < FIRST_PSEUDO_REGISTER
86 && ORIGINAL_REGNO (XEXP (x
, 0)) == REGNO (XEXP (x
, 0)))
91 if (shared_const_p (x
))
96 mem_mode
= GET_MODE (x
);
101 gcc_assert (mem_mode
!= VOIDmode
&& mem_mode
!= BLKmode
);
102 return gen_rtx_PLUS (GET_MODE (x
),
103 cleanup_auto_inc_dec (XEXP (x
, 0), mem_mode
),
104 gen_int_mode (code
== PRE_INC
105 ? GET_MODE_SIZE (mem_mode
)
106 : -GET_MODE_SIZE (mem_mode
),
113 return cleanup_auto_inc_dec (code
== PRE_MODIFY
114 ? XEXP (x
, 1) : XEXP (x
, 0),
121 /* Copy the various flags, fields, and other information. We assume
122 that all fields need copying, and then clear the fields that should
123 not be copied. That is the sensible default behavior, and forces
124 us to explicitly document why we are *not* copying a flag. */
125 x
= shallow_copy_rtx (x
);
127 /* We do not copy the USED flag, which is used as a mark bit during
128 walks over the RTL. */
129 RTX_FLAG (x
, used
) = 0;
131 /* We do not copy FRAME_RELATED for INSNs. */
133 RTX_FLAG (x
, frame_related
) = 0;
135 fmt
= GET_RTX_FORMAT (code
);
136 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
138 XEXP (x
, i
) = cleanup_auto_inc_dec (XEXP (x
, i
), mem_mode
);
139 else if (fmt
[i
] == 'E' || fmt
[i
] == 'V')
142 XVEC (x
, i
) = rtvec_alloc (XVECLEN (x
, i
));
143 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
145 = cleanup_auto_inc_dec (XVECEXP (src
, i
, j
), mem_mode
);
148 #else /* !AUTO_INC_DEC */
150 #endif /* !AUTO_INC_DEC */
155 /* Auxiliary data structure for propagate_for_debug_stmt. */
157 struct rtx_subst_pair
163 /* DATA points to an rtx_subst_pair. Return the value that should be
167 propagate_for_debug_subst (rtx from
, const_rtx old_rtx
, void *data
)
169 struct rtx_subst_pair
*pair
= (struct rtx_subst_pair
*)data
;
171 if (!rtx_equal_p (from
, old_rtx
))
175 pair
->adjusted
= true;
176 pair
->to
= cleanup_auto_inc_dec (pair
->to
, VOIDmode
);
177 pair
->to
= make_compound_operation (pair
->to
, SET
);
180 return copy_rtx (pair
->to
);
183 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
184 and LAST, not including INSN, but including LAST. Also stop at the end
185 of THIS_BASIC_BLOCK. */
188 propagate_for_debug (rtx_insn
*insn
, rtx_insn
*last
, rtx dest
, rtx src
,
189 basic_block this_basic_block
)
191 rtx_insn
*next
, *end
= NEXT_INSN (BB_END (this_basic_block
));
193 rtx (*saved_rtl_hook_no_emit
) (enum machine_mode
, rtx
);
195 struct rtx_subst_pair p
;
199 next
= NEXT_INSN (insn
);
200 last
= NEXT_INSN (last
);
201 saved_rtl_hook_no_emit
= rtl_hooks
.gen_lowpart_no_emit
;
202 rtl_hooks
.gen_lowpart_no_emit
= gen_lowpart_for_debug
;
203 while (next
!= last
&& next
!= end
)
206 next
= NEXT_INSN (insn
);
207 if (DEBUG_INSN_P (insn
))
209 loc
= simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn
),
210 dest
, propagate_for_debug_subst
, &p
);
211 if (loc
== INSN_VAR_LOCATION_LOC (insn
))
213 INSN_VAR_LOCATION_LOC (insn
) = loc
;
214 df_insn_rescan (insn
);
217 rtl_hooks
.gen_lowpart_no_emit
= saved_rtl_hook_no_emit
;
220 /* Initialize DEBUG to an empty list, and clear USED, if given. */
223 dead_debug_global_init (struct dead_debug_global
*debug
, bitmap used
)
231 /* Initialize DEBUG to an empty list, and clear USED, if given. Link
232 back to GLOBAL, if given, and bring in used bits from it. */
235 dead_debug_local_init (struct dead_debug_local
*debug
, bitmap used
,
236 struct dead_debug_global
*global
)
238 if (!used
&& global
&& global
->used
)
239 used
= BITMAP_ALLOC (NULL
);
242 debug
->global
= global
;
244 debug
->to_rescan
= NULL
;
248 if (global
&& global
->used
)
249 bitmap_copy (used
, global
->used
);
255 /* Locate the entry for REG in GLOBAL->htab. */
257 static dead_debug_global_entry
*
258 dead_debug_global_find (struct dead_debug_global
*global
, rtx reg
)
260 dead_debug_global_entry temp_entry
;
261 temp_entry
.reg
= reg
;
263 dead_debug_global_entry
*entry
= global
->htab
->find (&temp_entry
);
264 gcc_checking_assert (entry
&& entry
->reg
== temp_entry
.reg
);
269 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
271 static dead_debug_global_entry
*
272 dead_debug_global_insert (struct dead_debug_global
*global
, rtx reg
, rtx dtemp
)
274 dead_debug_global_entry temp_entry
;
275 temp_entry
.reg
= reg
;
276 temp_entry
.dtemp
= dtemp
;
279 global
->htab
= new hash_table
<dead_debug_hash_descr
> (31);
281 dead_debug_global_entry
**slot
= global
->htab
->find_slot (&temp_entry
,
283 gcc_checking_assert (!*slot
);
284 *slot
= XNEW (dead_debug_global_entry
);
289 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
290 replace it with with a USE of the debug temp recorded for it, and
291 return TRUE. Otherwise, just return FALSE.
293 If PTO_RESCAN is given, instead of rescanning modified INSNs right
294 away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
298 dead_debug_global_replace_temp (struct dead_debug_global
*global
,
299 df_ref use
, unsigned int uregno
,
302 if (!global
|| uregno
< FIRST_PSEUDO_REGISTER
304 || !REG_P (*DF_REF_REAL_LOC (use
))
305 || REGNO (*DF_REF_REAL_LOC (use
)) != uregno
306 || !bitmap_bit_p (global
->used
, uregno
))
309 dead_debug_global_entry
*entry
310 = dead_debug_global_find (global
, *DF_REF_REAL_LOC (use
));
311 gcc_checking_assert (GET_CODE (entry
->reg
) == REG
312 && REGNO (entry
->reg
) == uregno
);
317 *DF_REF_REAL_LOC (use
) = entry
->dtemp
;
319 df_insn_rescan (DF_REF_INSN (use
));
323 *pto_rescan
= BITMAP_ALLOC (NULL
);
324 bitmap_set_bit (*pto_rescan
, INSN_UID (DF_REF_INSN (use
)));
330 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
331 each reset insn. DEBUG is not otherwise modified. If HEAD is
332 DEBUG->head, DEBUG->head will be set to NULL at the end.
333 Otherwise, entries from DEBUG->head that pertain to reset insns
334 will be removed, and only then rescanned. */
337 dead_debug_reset_uses (struct dead_debug_local
*debug
,
338 struct dead_debug_use
*head
)
340 bool got_head
= (debug
->head
== head
);
342 struct dead_debug_use
**tailp
= &debug
->head
;
343 struct dead_debug_use
*cur
;
350 rescan
= BITMAP_ALLOC (NULL
);
354 struct dead_debug_use
*next
= head
->next
;
357 insn
= DF_REF_INSN (head
->use
);
358 if (!next
|| DF_REF_INSN (next
->use
) != insn
)
360 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
362 df_insn_rescan_debug_internal (insn
);
364 bitmap_set_bit (rescan
, INSN_UID (insn
));
365 if (debug
->to_rescan
)
366 bitmap_clear_bit (debug
->to_rescan
, INSN_UID (insn
));
378 while ((cur
= *tailp
))
379 if (bitmap_bit_p (rescan
, INSN_UID (DF_REF_INSN (cur
->use
))))
387 EXECUTE_IF_SET_IN_BITMAP (rescan
, 0, uid
, bi
)
389 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
391 df_insn_rescan_debug_internal (insn_info
->insn
);
394 BITMAP_FREE (rescan
);
397 /* Promote pending local uses of pseudos in DEBUG to global
398 substitutions. Uses of non-pseudos are left alone for
402 dead_debug_promote_uses (struct dead_debug_local
*debug
)
404 for (struct dead_debug_use
*head
= debug
->head
, **headp
= &debug
->head
;
407 rtx reg
= *DF_REF_REAL_LOC (head
->use
);
409 dead_debug_global_entry
*entry
;
411 if (GET_CODE (reg
) != REG
412 || REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
418 if (!debug
->global
->used
)
419 debug
->global
->used
= BITMAP_ALLOC (NULL
);
421 bool added
= bitmap_set_bit (debug
->global
->used
, REGNO (reg
));
422 gcc_checking_assert (added
);
424 entry
= dead_debug_global_insert (debug
->global
, reg
,
425 make_debug_expr_from_rtl (reg
));
427 gcc_checking_assert (entry
->dtemp
);
429 /* Tentatively remove the USE from the list. */
432 if (!debug
->to_rescan
)
433 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
435 for (ref
= DF_REG_USE_CHAIN (REGNO (reg
)); ref
;
436 ref
= DF_REF_NEXT_REG (ref
))
437 if (DEBUG_INSN_P (DF_REF_INSN (ref
)))
439 if (!dead_debug_global_replace_temp (debug
->global
, ref
,
443 rtx_insn
*insn
= DF_REF_INSN (ref
);
444 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
445 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
449 for (ref
= DF_REG_DEF_CHAIN (REGNO (reg
)); ref
;
450 ref
= DF_REF_NEXT_REG (ref
))
451 if (!dead_debug_insert_temp (debug
, REGNO (reg
), DF_REF_INSN (ref
),
452 DEBUG_TEMP_BEFORE_WITH_VALUE
))
455 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
456 DEBUG_EXPR_TREE_DECL (entry
->dtemp
),
457 gen_rtx_UNKNOWN_VAR_LOC (),
458 VAR_INIT_STATUS_INITIALIZED
);
459 rtx_insn
*insn
= emit_debug_insn_before (bind
, DF_REF_INSN (ref
));
460 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
468 /* Reset all debug insns with pending uses. Release the bitmap in it,
469 unless it is USED. USED must be the same bitmap passed to
470 dead_debug_local_init. */
473 dead_debug_local_finish (struct dead_debug_local
*debug
, bitmap used
)
476 dead_debug_promote_uses (debug
);
478 if (debug
->used
!= used
)
479 BITMAP_FREE (debug
->used
);
481 dead_debug_reset_uses (debug
, debug
->head
);
483 if (debug
->to_rescan
)
488 EXECUTE_IF_SET_IN_BITMAP (debug
->to_rescan
, 0, uid
, bi
)
490 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
492 df_insn_rescan (insn_info
->insn
);
494 BITMAP_FREE (debug
->to_rescan
);
498 /* Release GLOBAL->used unless it is the same as USED. Release the
499 mapping hash table if it was initialized. */
502 dead_debug_global_finish (struct dead_debug_global
*global
, bitmap used
)
504 if (global
->used
!= used
)
505 BITMAP_FREE (global
->used
);
511 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
512 the global substitution list. USE must be a dead reference to
513 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
516 dead_debug_add (struct dead_debug_local
*debug
, df_ref use
, unsigned int uregno
)
518 if (dead_debug_global_replace_temp (debug
->global
, use
, uregno
,
522 struct dead_debug_use
*newddu
= XNEW (struct dead_debug_use
);
525 newddu
->next
= debug
->head
;
526 debug
->head
= newddu
;
529 debug
->used
= BITMAP_ALLOC (NULL
);
531 /* ??? If we dealt with split multi-registers below, we should set
532 all registers for the used mode in case of hardware
534 bitmap_set_bit (debug
->used
, uregno
);
537 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
538 before or after INSN (depending on WHERE), that binds a (possibly
539 global) debug temp to the widest-mode use of UREGNO, if WHERE is
540 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
541 replace all uses of UREGNO in DEBUG with uses of the debug temp.
542 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
543 is set otherwise. Return the number of debug insns emitted. */
546 dead_debug_insert_temp (struct dead_debug_local
*debug
, unsigned int uregno
,
547 rtx_insn
*insn
, enum debug_temp_where where
)
549 struct dead_debug_use
**tailp
= &debug
->head
;
550 struct dead_debug_use
*cur
;
551 struct dead_debug_use
*uses
= NULL
;
552 struct dead_debug_use
**usesp
= &uses
;
562 global
= (debug
->global
&& debug
->global
->used
563 && bitmap_bit_p (debug
->global
->used
, uregno
));
565 if (!global
&& !bitmap_clear_bit (debug
->used
, uregno
))
568 /* Move all uses of uregno from debug->head to uses, setting mode to
569 the widest referenced mode. */
570 while ((cur
= *tailp
))
572 if (DF_REF_REGNO (cur
->use
) == uregno
)
574 /* If this loc has been changed e.g. to debug_expr already
575 as part of a multi-register use, just drop it. */
576 if (!REG_P (*DF_REF_REAL_LOC (cur
->use
)))
587 || (GET_MODE_BITSIZE (GET_MODE (reg
))
588 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)))))
589 reg
= *DF_REF_REAL_LOC (cur
->use
);
592 tailp
= &(*tailp
)->next
;
595 /* We may have dangling bits in debug->used for registers that were part
596 of a multi-register use, one component of which has been reset. */
599 gcc_checking_assert (!uses
);
607 reg
= regno_reg_rtx
[uregno
];
608 dead_debug_global_entry
*entry
609 = dead_debug_global_find (debug
->global
, reg
);
610 gcc_checking_assert (entry
->reg
== reg
);
616 gcc_checking_assert (uses
|| global
);
619 /* Recover the expression INSN stores in REG. */
620 if (where
== DEBUG_TEMP_BEFORE_WITH_VALUE
)
622 rtx set
= single_set (insn
);
627 dest
= SET_DEST (set
);
629 /* Lose if the REG-setting insn is a CALL. */
630 if (GET_CODE (src
) == CALL
)
642 /* ??? Should we try to extract it from a PARALLEL? */
645 /* Cool, it's the same REG, we can use SRC. */
646 else if (dest
== reg
)
647 breg
= cleanup_auto_inc_dec (src
, VOIDmode
);
648 else if (REG_P (dest
))
650 /* Hmm... Something's fishy, we should be setting REG here. */
651 if (REGNO (dest
) != REGNO (reg
))
653 /* If we're not overwriting all the hardware registers that
654 setting REG in its mode would, we won't know what to bind
655 the debug temp to. ??? We could bind the debug_expr to a
656 CONCAT or PARALLEL with the split multi-registers, and
657 replace them as we found the corresponding sets. */
658 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
659 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
660 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
662 /* Ok, it's the same (hardware) REG, but with a different
663 mode, so SUBREG it. */
665 breg
= lowpart_subreg (GET_MODE (reg
),
666 cleanup_auto_inc_dec (src
, VOIDmode
),
669 else if (GET_CODE (dest
) == SUBREG
)
671 /* We should be setting REG here. Lose. */
672 if (REGNO (SUBREG_REG (dest
)) != REGNO (reg
))
674 /* Lose if we're setting something other than the lowpart of
676 else if (!subreg_lowpart_p (dest
))
678 /* If we're not overwriting all the hardware registers that
679 setting REG in its mode would, we won't know what to bind
680 the debug temp to. */
681 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
682 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
683 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
685 /* Yay, we can use SRC, just adjust its mode. */
687 breg
= lowpart_subreg (GET_MODE (reg
),
688 cleanup_auto_inc_dec (src
, VOIDmode
),
691 /* Oh well, we're out of luck. */
695 /* We couldn't figure out the value stored in REG, so reset all
696 of its pending debug uses. */
699 dead_debug_reset_uses (debug
, uses
);
704 /* If there's a single (debug) use of an otherwise unused REG, and
705 the debug use is not part of a larger expression, then it
706 probably doesn't make sense to introduce a new debug temp. */
707 if (where
== DEBUG_TEMP_AFTER_WITH_REG
&& !uses
->next
)
709 rtx_insn
*next
= DF_REF_INSN (uses
->use
);
711 if (DEBUG_INSN_P (next
) && reg
== INSN_VAR_LOCATION_LOC (next
))
719 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
720 dval
= make_debug_expr_from_rtl (reg
);
722 /* Emit a debug bind insn before the insn in which reg dies. */
723 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
724 DEBUG_EXPR_TREE_DECL (dval
), breg
,
725 VAR_INIT_STATUS_INITIALIZED
);
727 if (where
== DEBUG_TEMP_AFTER_WITH_REG
728 || where
== DEBUG_TEMP_AFTER_WITH_REG_FORCE
)
729 bind
= emit_debug_insn_after (bind
, insn
);
731 bind
= emit_debug_insn_before (bind
, insn
);
732 if (debug
->to_rescan
== NULL
)
733 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
734 bitmap_set_bit (debug
->to_rescan
, INSN_UID (bind
));
736 /* Adjust all uses. */
739 if (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)) == GET_MODE (reg
))
740 *DF_REF_REAL_LOC (cur
->use
) = dval
;
742 *DF_REF_REAL_LOC (cur
->use
)
743 = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)), dval
);
744 /* ??? Should we simplify subreg of subreg? */
745 bitmap_set_bit (debug
->to_rescan
, INSN_UID (DF_REF_INSN (cur
->use
)));