1 /* Infrastructure for tracking user variable locations and values
2 throughout compilation.
3 Copyright (C) 2010, 2011, 2012 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 /* Replace auto-increment addressing modes with explicit operations to access
33 the same addresses without modifying the corresponding registers. */
36 cleanup_auto_inc_dec (rtx src
, enum machine_mode mem_mode ATTRIBUTE_UNUSED
)
40 const RTX_CODE code
= GET_CODE (x
);
53 /* SCRATCH must be shared because they represent distinct values. */
56 if (REG_P (XEXP (x
, 0)) && REGNO (XEXP (x
, 0)) < FIRST_PSEUDO_REGISTER
)
61 if (shared_const_p (x
))
66 mem_mode
= GET_MODE (x
);
71 gcc_assert (mem_mode
!= VOIDmode
&& mem_mode
!= BLKmode
);
72 return gen_rtx_PLUS (GET_MODE (x
),
73 cleanup_auto_inc_dec (XEXP (x
, 0), mem_mode
),
74 GEN_INT (code
== PRE_INC
75 ? GET_MODE_SIZE (mem_mode
)
76 : -GET_MODE_SIZE (mem_mode
)));
82 return cleanup_auto_inc_dec (code
== PRE_MODIFY
83 ? XEXP (x
, 1) : XEXP (x
, 0),
90 /* Copy the various flags, fields, and other information. We assume
91 that all fields need copying, and then clear the fields that should
92 not be copied. That is the sensible default behavior, and forces
93 us to explicitly document why we are *not* copying a flag. */
94 x
= shallow_copy_rtx (x
);
96 /* We do not copy the USED flag, which is used as a mark bit during
97 walks over the RTL. */
98 RTX_FLAG (x
, used
) = 0;
100 /* We do not copy FRAME_RELATED for INSNs. */
102 RTX_FLAG (x
, frame_related
) = 0;
104 fmt
= GET_RTX_FORMAT (code
);
105 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
107 XEXP (x
, i
) = cleanup_auto_inc_dec (XEXP (x
, i
), mem_mode
);
108 else if (fmt
[i
] == 'E' || fmt
[i
] == 'V')
111 XVEC (x
, i
) = rtvec_alloc (XVECLEN (x
, i
));
112 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
114 = cleanup_auto_inc_dec (XVECEXP (src
, i
, j
), mem_mode
);
117 #else /* !AUTO_INC_DEC */
119 #endif /* !AUTO_INC_DEC */
124 /* Auxiliary data structure for propagate_for_debug_stmt. */
126 struct rtx_subst_pair
132 /* DATA points to an rtx_subst_pair. Return the value that should be
136 propagate_for_debug_subst (rtx from
, const_rtx old_rtx
, void *data
)
138 struct rtx_subst_pair
*pair
= (struct rtx_subst_pair
*)data
;
140 if (!rtx_equal_p (from
, old_rtx
))
144 pair
->adjusted
= true;
145 pair
->to
= cleanup_auto_inc_dec (pair
->to
, VOIDmode
);
146 pair
->to
= make_compound_operation (pair
->to
, SET
);
149 return copy_rtx (pair
->to
);
152 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
153 and LAST, not including INSN, but including LAST. Also stop at the end
154 of THIS_BASIC_BLOCK. */
157 propagate_for_debug (rtx insn
, rtx last
, rtx dest
, rtx src
,
158 basic_block this_basic_block
)
160 rtx next
, loc
, end
= NEXT_INSN (BB_END (this_basic_block
));
162 struct rtx_subst_pair p
;
166 next
= NEXT_INSN (insn
);
167 last
= NEXT_INSN (last
);
168 while (next
!= last
&& next
!= end
)
171 next
= NEXT_INSN (insn
);
172 if (DEBUG_INSN_P (insn
))
174 loc
= simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn
),
175 dest
, propagate_for_debug_subst
, &p
);
176 if (loc
== INSN_VAR_LOCATION_LOC (insn
))
178 INSN_VAR_LOCATION_LOC (insn
) = loc
;
179 df_insn_rescan (insn
);
184 /* Initialize DEBUG to an empty list, and clear USED, if given. */
187 dead_debug_global_init (struct dead_debug_global
*debug
, bitmap used
)
194 /* Initialize DEBUG to an empty list, and clear USED, if given. Link
195 back to GLOBAL, if given, and bring in used bits from it. */
198 dead_debug_local_init (struct dead_debug_local
*debug
, bitmap used
,
199 struct dead_debug_global
*global
)
201 if (!used
&& global
&& global
->used
)
202 used
= BITMAP_ALLOC (NULL
);
205 debug
->global
= global
;
207 debug
->to_rescan
= NULL
;
211 if (global
&& global
->used
)
212 bitmap_copy (used
, global
->used
);
218 /* Locate the entry for REG in GLOBAL->htab. */
220 static dead_debug_global_entry
*
221 dead_debug_global_find (struct dead_debug_global
*global
, rtx reg
)
223 dead_debug_global_entry temp_entry
;
224 temp_entry
.reg
= reg
;
226 dead_debug_global_entry
*entry
= global
->htab
.find (&temp_entry
);
227 gcc_checking_assert (entry
&& entry
->reg
== temp_entry
.reg
);
232 /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
234 static dead_debug_global_entry
*
235 dead_debug_global_insert (struct dead_debug_global
*global
, rtx reg
, rtx dtemp
)
237 dead_debug_global_entry temp_entry
;
238 temp_entry
.reg
= reg
;
239 temp_entry
.dtemp
= dtemp
;
241 if (!global
->htab
.is_created ())
242 global
->htab
.create (31);
244 dead_debug_global_entry
**slot
= global
->htab
.find_slot (&temp_entry
, INSERT
);
245 gcc_checking_assert (!*slot
);
246 *slot
= XNEW (dead_debug_global_entry
);
251 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
252 replace it with with a USE of the debug temp recorded for it, and
253 return TRUE. Otherwise, just return FALSE.
255 If PTO_RESCAN is given, instead of rescanning modified INSNs right
256 away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
260 dead_debug_global_replace_temp (struct dead_debug_global
*global
,
261 df_ref use
, unsigned int uregno
,
264 if (!global
|| uregno
< FIRST_PSEUDO_REGISTER
266 || !REG_P (*DF_REF_REAL_LOC (use
))
267 || REGNO (*DF_REF_REAL_LOC (use
)) != uregno
268 || !bitmap_bit_p (global
->used
, uregno
))
271 dead_debug_global_entry
*entry
272 = dead_debug_global_find (global
, *DF_REF_REAL_LOC (use
));
273 gcc_checking_assert (GET_CODE (entry
->reg
) == REG
274 && REGNO (entry
->reg
) == uregno
);
279 *DF_REF_REAL_LOC (use
) = entry
->dtemp
;
281 df_insn_rescan (DF_REF_INSN (use
));
285 *pto_rescan
= BITMAP_ALLOC (NULL
);
286 bitmap_set_bit (*pto_rescan
, INSN_UID (DF_REF_INSN (use
)));
292 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
293 each reset insn. DEBUG is not otherwise modified. If HEAD is
294 DEBUG->head, DEBUG->head will be set to NULL at the end.
295 Otherwise, entries from DEBUG->head that pertain to reset insns
296 will be removed, and only then rescanned. */
299 dead_debug_reset_uses (struct dead_debug_local
*debug
,
300 struct dead_debug_use
*head
)
302 bool got_head
= (debug
->head
== head
);
304 struct dead_debug_use
**tailp
= &debug
->head
;
305 struct dead_debug_use
*cur
;
312 rescan
= BITMAP_ALLOC (NULL
);
316 struct dead_debug_use
*next
= head
->next
;
319 insn
= DF_REF_INSN (head
->use
);
320 if (!next
|| DF_REF_INSN (next
->use
) != insn
)
322 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
324 df_insn_rescan_debug_internal (insn
);
326 bitmap_set_bit (rescan
, INSN_UID (insn
));
327 if (debug
->to_rescan
)
328 bitmap_clear_bit (debug
->to_rescan
, INSN_UID (insn
));
340 while ((cur
= *tailp
))
341 if (bitmap_bit_p (rescan
, INSN_UID (DF_REF_INSN (cur
->use
))))
349 EXECUTE_IF_SET_IN_BITMAP (rescan
, 0, uid
, bi
)
351 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
353 df_insn_rescan_debug_internal (insn_info
->insn
);
356 BITMAP_FREE (rescan
);
359 /* Promote pending local uses of pseudos in DEBUG to global
360 substitutions. Uses of non-pseudos are left alone for
364 dead_debug_promote_uses (struct dead_debug_local
*debug
)
366 for (struct dead_debug_use
*head
= debug
->head
, **headp
= &debug
->head
;
369 rtx reg
= *DF_REF_REAL_LOC (head
->use
);
371 dead_debug_global_entry
*entry
;
373 if (GET_CODE (reg
) != REG
374 || REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
380 if (!debug
->global
->used
)
381 debug
->global
->used
= BITMAP_ALLOC (NULL
);
383 if (bitmap_set_bit (debug
->global
->used
, REGNO (reg
)))
384 entry
= dead_debug_global_insert (debug
->global
, reg
,
385 make_debug_expr_from_rtl (reg
));
387 gcc_checking_assert (entry
->dtemp
);
389 /* Tentatively remove the USE from the list. */
392 if (!debug
->to_rescan
)
393 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
395 for (ref
= DF_REG_USE_CHAIN (REGNO (reg
)); ref
;
396 ref
= DF_REF_NEXT_REG (ref
))
397 if (DEBUG_INSN_P (DF_REF_INSN (ref
)))
399 if (!dead_debug_global_replace_temp (debug
->global
, ref
,
403 rtx insn
= DF_REF_INSN (ref
);
404 INSN_VAR_LOCATION_LOC (insn
) = gen_rtx_UNKNOWN_VAR_LOC ();
405 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
409 for (ref
= DF_REG_DEF_CHAIN (REGNO (reg
)); ref
;
410 ref
= DF_REF_NEXT_REG (ref
))
411 if (!dead_debug_insert_temp (debug
, REGNO (reg
), DF_REF_INSN (ref
),
412 DEBUG_TEMP_BEFORE_WITH_VALUE
))
415 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
416 DEBUG_EXPR_TREE_DECL (entry
->dtemp
),
417 gen_rtx_UNKNOWN_VAR_LOC (),
418 VAR_INIT_STATUS_INITIALIZED
);
419 rtx insn
= emit_debug_insn_before (bind
, DF_REF_INSN (ref
));
420 bitmap_set_bit (debug
->to_rescan
, INSN_UID (insn
));
428 /* Reset all debug insns with pending uses. Release the bitmap in it,
429 unless it is USED. USED must be the same bitmap passed to
430 dead_debug_local_init. */
433 dead_debug_local_finish (struct dead_debug_local
*debug
, bitmap used
)
436 dead_debug_promote_uses (debug
);
438 if (debug
->used
!= used
)
439 BITMAP_FREE (debug
->used
);
441 dead_debug_reset_uses (debug
, debug
->head
);
443 if (debug
->to_rescan
)
448 EXECUTE_IF_SET_IN_BITMAP (debug
->to_rescan
, 0, uid
, bi
)
450 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
452 df_insn_rescan (insn_info
->insn
);
454 BITMAP_FREE (debug
->to_rescan
);
458 /* Release GLOBAL->used unless it is the same as USED. Release the
459 mapping hash table if it was initialized. */
462 dead_debug_global_finish (struct dead_debug_global
*global
, bitmap used
)
464 if (global
->used
!= used
)
465 BITMAP_FREE (global
->used
);
467 if (global
->htab
.is_created ())
468 global
->htab
.dispose ();
471 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
472 the global substitution list. USE must be a dead reference to
473 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
476 dead_debug_add (struct dead_debug_local
*debug
, df_ref use
, unsigned int uregno
)
478 if (dead_debug_global_replace_temp (debug
->global
, use
, uregno
,
482 struct dead_debug_use
*newddu
= XNEW (struct dead_debug_use
);
485 newddu
->next
= debug
->head
;
486 debug
->head
= newddu
;
489 debug
->used
= BITMAP_ALLOC (NULL
);
491 /* ??? If we dealt with split multi-registers below, we should set
492 all registers for the used mode in case of hardware
494 bitmap_set_bit (debug
->used
, uregno
);
497 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
498 before or after INSN (depending on WHERE), that binds a (possibly
499 global) debug temp to the widest-mode use of UREGNO, if WHERE is
500 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
501 replace all uses of UREGNO in DEBUG with uses of the debug temp.
502 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
503 is set otherwise. Return the number of debug insns emitted. */
506 dead_debug_insert_temp (struct dead_debug_local
*debug
, unsigned int uregno
,
507 rtx insn
, enum debug_temp_where where
)
509 struct dead_debug_use
**tailp
= &debug
->head
;
510 struct dead_debug_use
*cur
;
511 struct dead_debug_use
*uses
= NULL
;
512 struct dead_debug_use
**usesp
= &uses
;
522 global
= (debug
->global
&& debug
->global
->used
523 && bitmap_bit_p (debug
->global
->used
, uregno
));
525 if (!global
&& !bitmap_clear_bit (debug
->used
, uregno
))
528 /* Move all uses of uregno from debug->head to uses, setting mode to
529 the widest referenced mode. */
530 while ((cur
= *tailp
))
532 if (DF_REF_REGNO (cur
->use
) == uregno
)
534 /* If this loc has been changed e.g. to debug_expr already
535 as part of a multi-register use, just drop it. */
536 if (!REG_P (*DF_REF_REAL_LOC (cur
->use
)))
547 || (GET_MODE_BITSIZE (GET_MODE (reg
))
548 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)))))
549 reg
= *DF_REF_REAL_LOC (cur
->use
);
552 tailp
= &(*tailp
)->next
;
555 /* We may have dangling bits in debug->used for registers that were part
556 of a multi-register use, one component of which has been reset. */
559 gcc_checking_assert (!uses
);
567 reg
= regno_reg_rtx
[uregno
];
568 dead_debug_global_entry
*entry
569 = dead_debug_global_find (debug
->global
, reg
);
570 gcc_checking_assert (entry
->reg
== reg
);
576 gcc_checking_assert (uses
|| global
);
579 /* Recover the expression INSN stores in REG. */
580 if (where
== DEBUG_TEMP_BEFORE_WITH_VALUE
)
582 rtx set
= single_set (insn
);
587 dest
= SET_DEST (set
);
589 /* Lose if the REG-setting insn is a CALL. */
590 if (GET_CODE (src
) == CALL
)
602 /* ??? Should we try to extract it from a PARALLEL? */
605 /* Cool, it's the same REG, we can use SRC. */
606 else if (dest
== reg
)
607 breg
= cleanup_auto_inc_dec (src
, VOIDmode
);
608 else if (REG_P (dest
))
610 /* Hmm... Something's fishy, we should be setting REG here. */
611 if (REGNO (dest
) != REGNO (reg
))
613 /* If we're not overwriting all the hardware registers that
614 setting REG in its mode would, we won't know what to bind
615 the debug temp to. ??? We could bind the debug_expr to a
616 CONCAT or PARALLEL with the split multi-registers, and
617 replace them as we found the corresponding sets. */
618 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
619 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
620 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
622 /* Ok, it's the same (hardware) REG, but with a different
623 mode, so SUBREG it. */
625 breg
= lowpart_subreg (GET_MODE (reg
),
626 cleanup_auto_inc_dec (src
, VOIDmode
),
629 else if (GET_CODE (dest
) == SUBREG
)
631 /* We should be setting REG here. Lose. */
632 if (REGNO (SUBREG_REG (dest
)) != REGNO (reg
))
634 /* Lose if we're setting something other than the lowpart of
636 else if (!subreg_lowpart_p (dest
))
638 /* If we're not overwriting all the hardware registers that
639 setting REG in its mode would, we won't know what to bind
640 the debug temp to. */
641 else if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
642 && (hard_regno_nregs
[REGNO (reg
)][GET_MODE (reg
)]
643 != hard_regno_nregs
[REGNO (reg
)][GET_MODE (dest
)]))
645 /* Yay, we can use SRC, just adjust its mode. */
647 breg
= lowpart_subreg (GET_MODE (reg
),
648 cleanup_auto_inc_dec (src
, VOIDmode
),
651 /* Oh well, we're out of luck. */
655 /* We couldn't figure out the value stored in REG, so reset all
656 of its pending debug uses. */
659 dead_debug_reset_uses (debug
, uses
);
664 /* If there's a single (debug) use of an otherwise unused REG, and
665 the debug use is not part of a larger expression, then it
666 probably doesn't make sense to introduce a new debug temp. */
667 if (where
== DEBUG_TEMP_AFTER_WITH_REG
&& !uses
->next
)
669 rtx next
= DF_REF_INSN (uses
->use
);
671 if (DEBUG_INSN_P (next
) && reg
== INSN_VAR_LOCATION_LOC (next
))
679 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
680 dval
= make_debug_expr_from_rtl (reg
);
682 /* Emit a debug bind insn before the insn in which reg dies. */
683 bind
= gen_rtx_VAR_LOCATION (GET_MODE (reg
),
684 DEBUG_EXPR_TREE_DECL (dval
), breg
,
685 VAR_INIT_STATUS_INITIALIZED
);
687 if (where
== DEBUG_TEMP_AFTER_WITH_REG
)
688 bind
= emit_debug_insn_after (bind
, insn
);
690 bind
= emit_debug_insn_before (bind
, insn
);
691 if (debug
->to_rescan
== NULL
)
692 debug
->to_rescan
= BITMAP_ALLOC (NULL
);
693 bitmap_set_bit (debug
->to_rescan
, INSN_UID (bind
));
695 /* Adjust all uses. */
698 if (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)) == GET_MODE (reg
))
699 *DF_REF_REAL_LOC (cur
->use
) = dval
;
701 *DF_REF_REAL_LOC (cur
->use
)
702 = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur
->use
)), dval
);
703 /* ??? Should we simplify subreg of subreg? */
704 bitmap_set_bit (debug
->to_rescan
, INSN_UID (DF_REF_INSN (cur
->use
)));