2012-11-28 Oleg Raikhman <oleg@adapteva.com>
[official-gcc.git] / gcc / valtrack.c
blob5eefabd2aed104448a2ff2f346368b6aacfbee6f
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
11 version.
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.
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/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "valtrack.h"
28 #include "function.h"
29 #include "regs.h"
30 #include "emit-rtl.h"
32 /* Replace auto-increment addressing modes with explicit operations to access
33 the same addresses without modifying the corresponding registers. */
35 static rtx
36 cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode ATTRIBUTE_UNUSED)
38 rtx x = src;
39 #ifdef AUTO_INC_DEC
40 const RTX_CODE code = GET_CODE (x);
41 int i;
42 const char *fmt;
44 switch (code)
46 case REG:
47 CASE_CONST_ANY:
48 case SYMBOL_REF:
49 case CODE_LABEL:
50 case PC:
51 case CC0:
52 case SCRATCH:
53 /* SCRATCH must be shared because they represent distinct values. */
54 return x;
55 case CLOBBER:
56 if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
57 return x;
58 break;
60 case CONST:
61 if (shared_const_p (x))
62 return x;
63 break;
65 case MEM:
66 mem_mode = GET_MODE (x);
67 break;
69 case PRE_INC:
70 case PRE_DEC:
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)));
78 case POST_INC:
79 case POST_DEC:
80 case PRE_MODIFY:
81 case POST_MODIFY:
82 return cleanup_auto_inc_dec (code == PRE_MODIFY
83 ? XEXP (x, 1) : XEXP (x, 0),
84 mem_mode);
86 default:
87 break;
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. */
101 if (INSN_P (x))
102 RTX_FLAG (x, frame_related) = 0;
104 fmt = GET_RTX_FORMAT (code);
105 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
106 if (fmt[i] == 'e')
107 XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
108 else if (fmt[i] == 'E' || fmt[i] == 'V')
110 int j;
111 XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
112 for (j = 0; j < XVECLEN (x, i); j++)
113 XVECEXP (x, i, j)
114 = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
117 #else /* !AUTO_INC_DEC */
118 x = copy_rtx (x);
119 #endif /* !AUTO_INC_DEC */
121 return x;
124 /* Auxiliary data structure for propagate_for_debug_stmt. */
126 struct rtx_subst_pair
128 rtx to;
129 bool adjusted;
132 /* DATA points to an rtx_subst_pair. Return the value that should be
133 substituted. */
135 static rtx
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))
141 return NULL_RTX;
142 if (!pair->adjusted)
144 pair->adjusted = true;
145 pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
146 pair->to = make_compound_operation (pair->to, SET);
147 return pair->to;
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. */
156 void
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;
163 p.to = src;
164 p.adjusted = false;
166 next = NEXT_INSN (insn);
167 last = NEXT_INSN (last);
168 while (next != last && next != end)
170 insn = next;
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))
177 continue;
178 INSN_VAR_LOCATION_LOC (insn) = loc;
179 df_insn_rescan (insn);
184 /* Initialize DEBUG to an empty list, and clear USED, if given. */
186 void
187 dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
189 debug->used = used;
190 if (used)
191 bitmap_clear (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. */
197 void
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);
204 debug->head = NULL;
205 debug->global = global;
206 debug->used = used;
207 debug->to_rescan = NULL;
209 if (used)
211 if (global && global->used)
212 bitmap_copy (used, global->used);
213 else
214 bitmap_clear (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);
229 return entry;
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);
247 **slot = temp_entry;
248 return *slot;
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
257 is NULL. */
259 static bool
260 dead_debug_global_replace_temp (struct dead_debug_global *global,
261 df_ref use, unsigned int uregno,
262 bitmap *pto_rescan)
264 if (!global || uregno < FIRST_PSEUDO_REGISTER
265 || !global->used
266 || !REG_P (*DF_REF_REAL_LOC (use))
267 || REGNO (*DF_REF_REAL_LOC (use)) != uregno
268 || !bitmap_bit_p (global->used, uregno))
269 return false;
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);
276 if (!entry->dtemp)
277 return true;
279 *DF_REF_REAL_LOC (use) = entry->dtemp;
280 if (!pto_rescan)
281 df_insn_rescan (DF_REF_INSN (use));
282 else
284 if (!*pto_rescan)
285 *pto_rescan = BITMAP_ALLOC (NULL);
286 bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
289 return true;
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. */
298 static void
299 dead_debug_reset_uses (struct dead_debug_local *debug,
300 struct dead_debug_use *head)
302 bool got_head = (debug->head == head);
303 bitmap rescan;
304 struct dead_debug_use **tailp = &debug->head;
305 struct dead_debug_use *cur;
306 bitmap_iterator bi;
307 unsigned int uid;
309 if (got_head)
310 rescan = NULL;
311 else
312 rescan = BITMAP_ALLOC (NULL);
314 while (head)
316 struct dead_debug_use *next = head->next;
317 rtx insn;
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 ();
323 if (got_head)
324 df_insn_rescan_debug_internal (insn);
325 else
326 bitmap_set_bit (rescan, INSN_UID (insn));
327 if (debug->to_rescan)
328 bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
330 XDELETE (head);
331 head = next;
334 if (got_head)
336 debug->head = NULL;
337 return;
340 while ((cur = *tailp))
341 if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
343 *tailp = cur->next;
344 XDELETE (cur);
346 else
347 tailp = &cur->next;
349 EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
351 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
352 if (insn_info)
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
361 resetting. */
363 static void
364 dead_debug_promote_uses (struct dead_debug_local *debug)
366 for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
367 head; head = *headp)
369 rtx reg = *DF_REF_REAL_LOC (head->use);
370 df_ref ref;
371 dead_debug_global_entry *entry;
373 if (GET_CODE (reg) != REG
374 || REGNO (reg) < FIRST_PSEUDO_REGISTER)
376 headp = &head->next;
377 continue;
380 if (!debug->global->used)
381 debug->global->used = BITMAP_ALLOC (NULL);
383 bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
384 gcc_checking_assert (added);
386 entry = dead_debug_global_insert (debug->global, reg,
387 make_debug_expr_from_rtl (reg));
389 gcc_checking_assert (entry->dtemp);
391 /* Tentatively remove the USE from the list. */
392 *headp = head->next;
394 if (!debug->to_rescan)
395 debug->to_rescan = BITMAP_ALLOC (NULL);
397 for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
398 ref = DF_REF_NEXT_REG (ref))
399 if (DEBUG_INSN_P (DF_REF_INSN (ref)))
401 if (!dead_debug_global_replace_temp (debug->global, ref,
402 REGNO (reg),
403 &debug->to_rescan))
405 rtx insn = DF_REF_INSN (ref);
406 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
407 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
411 for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
412 ref = DF_REF_NEXT_REG (ref))
413 if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
414 DEBUG_TEMP_BEFORE_WITH_VALUE))
416 rtx bind;
417 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
418 DEBUG_EXPR_TREE_DECL (entry->dtemp),
419 gen_rtx_UNKNOWN_VAR_LOC (),
420 VAR_INIT_STATUS_INITIALIZED);
421 rtx insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
422 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
425 entry->dtemp = NULL;
426 XDELETE (head);
430 /* Reset all debug insns with pending uses. Release the bitmap in it,
431 unless it is USED. USED must be the same bitmap passed to
432 dead_debug_local_init. */
434 void
435 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
437 if (debug->global)
438 dead_debug_promote_uses (debug);
440 if (debug->used != used)
441 BITMAP_FREE (debug->used);
443 dead_debug_reset_uses (debug, debug->head);
445 if (debug->to_rescan)
447 bitmap_iterator bi;
448 unsigned int uid;
450 EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
452 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
453 if (insn_info)
454 df_insn_rescan (insn_info->insn);
456 BITMAP_FREE (debug->to_rescan);
460 /* Release GLOBAL->used unless it is the same as USED. Release the
461 mapping hash table if it was initialized. */
463 void
464 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
466 if (global->used != used)
467 BITMAP_FREE (global->used);
469 if (global->htab.is_created ())
470 global->htab.dispose ();
473 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
474 the global substitution list. USE must be a dead reference to
475 UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
477 void
478 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
480 if (dead_debug_global_replace_temp (debug->global, use, uregno,
481 &debug->to_rescan))
482 return;
484 struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
486 newddu->use = use;
487 newddu->next = debug->head;
488 debug->head = newddu;
490 if (!debug->used)
491 debug->used = BITMAP_ALLOC (NULL);
493 /* ??? If we dealt with split multi-registers below, we should set
494 all registers for the used mode in case of hardware
495 registers. */
496 bitmap_set_bit (debug->used, uregno);
499 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
500 before or after INSN (depending on WHERE), that binds a (possibly
501 global) debug temp to the widest-mode use of UREGNO, if WHERE is
502 *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
503 replace all uses of UREGNO in DEBUG with uses of the debug temp.
504 INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
505 is set otherwise. Return the number of debug insns emitted. */
508 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
509 rtx insn, enum debug_temp_where where)
511 struct dead_debug_use **tailp = &debug->head;
512 struct dead_debug_use *cur;
513 struct dead_debug_use *uses = NULL;
514 struct dead_debug_use **usesp = &uses;
515 rtx reg = NULL_RTX;
516 rtx breg;
517 rtx dval = NULL_RTX;
518 rtx bind;
519 bool global;
521 if (!debug->used)
522 return 0;
524 global = (debug->global && debug->global->used
525 && bitmap_bit_p (debug->global->used, uregno));
527 if (!global && !bitmap_clear_bit (debug->used, uregno))
528 return 0;
530 /* Move all uses of uregno from debug->head to uses, setting mode to
531 the widest referenced mode. */
532 while ((cur = *tailp))
534 if (DF_REF_REGNO (cur->use) == uregno)
536 /* If this loc has been changed e.g. to debug_expr already
537 as part of a multi-register use, just drop it. */
538 if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
540 *tailp = cur->next;
541 XDELETE (cur);
542 continue;
544 *usesp = cur;
545 usesp = &cur->next;
546 *tailp = cur->next;
547 cur->next = NULL;
548 if (!reg
549 || (GET_MODE_BITSIZE (GET_MODE (reg))
550 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
551 reg = *DF_REF_REAL_LOC (cur->use);
553 else
554 tailp = &(*tailp)->next;
557 /* We may have dangling bits in debug->used for registers that were part
558 of a multi-register use, one component of which has been reset. */
559 if (reg == NULL)
561 gcc_checking_assert (!uses);
562 if (!global)
563 return 0;
566 if (global)
568 if (!reg)
569 reg = regno_reg_rtx[uregno];
570 dead_debug_global_entry *entry
571 = dead_debug_global_find (debug->global, reg);
572 gcc_checking_assert (entry->reg == reg);
573 dval = entry->dtemp;
574 if (!dval)
575 return 0;
578 gcc_checking_assert (uses || global);
580 breg = reg;
581 /* Recover the expression INSN stores in REG. */
582 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
584 rtx set = single_set (insn);
585 rtx dest, src;
587 if (set)
589 dest = SET_DEST (set);
590 src = SET_SRC (set);
591 /* Lose if the REG-setting insn is a CALL. */
592 if (GET_CODE (src) == CALL)
594 while (uses)
596 cur = uses->next;
597 XDELETE (uses);
598 uses = cur;
600 return 0;
604 /* ??? Should we try to extract it from a PARALLEL? */
605 if (!set)
606 breg = NULL;
607 /* Cool, it's the same REG, we can use SRC. */
608 else if (dest == reg)
609 breg = cleanup_auto_inc_dec (src, VOIDmode);
610 else if (REG_P (dest))
612 /* Hmm... Something's fishy, we should be setting REG here. */
613 if (REGNO (dest) != REGNO (reg))
614 breg = NULL;
615 /* If we're not overwriting all the hardware registers that
616 setting REG in its mode would, we won't know what to bind
617 the debug temp to. ??? We could bind the debug_expr to a
618 CONCAT or PARALLEL with the split multi-registers, and
619 replace them as we found the corresponding sets. */
620 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
621 && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
622 != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
623 breg = NULL;
624 /* Ok, it's the same (hardware) REG, but with a different
625 mode, so SUBREG it. */
626 else
627 breg = lowpart_subreg (GET_MODE (reg),
628 cleanup_auto_inc_dec (src, VOIDmode),
629 GET_MODE (dest));
631 else if (GET_CODE (dest) == SUBREG)
633 /* We should be setting REG here. Lose. */
634 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
635 breg = NULL;
636 /* Lose if we're setting something other than the lowpart of
637 REG. */
638 else if (!subreg_lowpart_p (dest))
639 breg = NULL;
640 /* If we're not overwriting all the hardware registers that
641 setting REG in its mode would, we won't know what to bind
642 the debug temp to. */
643 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
644 && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
645 != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
646 breg = NULL;
647 /* Yay, we can use SRC, just adjust its mode. */
648 else
649 breg = lowpart_subreg (GET_MODE (reg),
650 cleanup_auto_inc_dec (src, VOIDmode),
651 GET_MODE (dest));
653 /* Oh well, we're out of luck. */
654 else
655 breg = NULL;
657 /* We couldn't figure out the value stored in REG, so reset all
658 of its pending debug uses. */
659 if (!breg)
661 dead_debug_reset_uses (debug, uses);
662 return 0;
666 /* If there's a single (debug) use of an otherwise unused REG, and
667 the debug use is not part of a larger expression, then it
668 probably doesn't make sense to introduce a new debug temp. */
669 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
671 rtx next = DF_REF_INSN (uses->use);
673 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
675 XDELETE (uses);
676 return 0;
680 if (!global)
681 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
682 dval = make_debug_expr_from_rtl (reg);
684 /* Emit a debug bind insn before the insn in which reg dies. */
685 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
686 DEBUG_EXPR_TREE_DECL (dval), breg,
687 VAR_INIT_STATUS_INITIALIZED);
689 if (where == DEBUG_TEMP_AFTER_WITH_REG
690 || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
691 bind = emit_debug_insn_after (bind, insn);
692 else
693 bind = emit_debug_insn_before (bind, insn);
694 if (debug->to_rescan == NULL)
695 debug->to_rescan = BITMAP_ALLOC (NULL);
696 bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
698 /* Adjust all uses. */
699 while ((cur = uses))
701 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
702 *DF_REF_REAL_LOC (cur->use) = dval;
703 else
704 *DF_REF_REAL_LOC (cur->use)
705 = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
706 /* ??? Should we simplify subreg of subreg? */
707 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
708 uses = cur->next;
709 XDELETE (cur);
712 return 1;