re PR debug/52983 (internal compiler error: in df_uses_record, at df-scan.c:3243)
[gcc.git] / gcc / valtrack.c
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>.
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 "tm.h"
26 #include "rtl.h"
27 #include "valtrack.h"
28 #include "function.h"
29 #include "regs.h"
30 #include "emit-rtl.h"
31
32 /* Replace auto-increment addressing modes with explicit operations to access
33 the same addresses without modifying the corresponding registers. */
34
35 static rtx
36 cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode ATTRIBUTE_UNUSED)
37 {
38 rtx x = src;
39 #ifdef AUTO_INC_DEC
40 const RTX_CODE code = GET_CODE (x);
41 int i;
42 const char *fmt;
43
44 switch (code)
45 {
46 case REG:
47 case CONST_INT:
48 case CONST_DOUBLE:
49 case CONST_FIXED:
50 case CONST_VECTOR:
51 case SYMBOL_REF:
52 case CODE_LABEL:
53 case PC:
54 case CC0:
55 case SCRATCH:
56 /* SCRATCH must be shared because they represent distinct values. */
57 return x;
58 case CLOBBER:
59 if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
60 return x;
61 break;
62
63 case CONST:
64 if (shared_const_p (x))
65 return x;
66 break;
67
68 case MEM:
69 mem_mode = GET_MODE (x);
70 break;
71
72 case PRE_INC:
73 case PRE_DEC:
74 gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
75 return gen_rtx_PLUS (GET_MODE (x),
76 cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
77 GEN_INT (code == PRE_INC
78 ? GET_MODE_SIZE (mem_mode)
79 : -GET_MODE_SIZE (mem_mode)));
80
81 case POST_INC:
82 case POST_DEC:
83 case PRE_MODIFY:
84 case POST_MODIFY:
85 return cleanup_auto_inc_dec (code == PRE_MODIFY
86 ? XEXP (x, 1) : XEXP (x, 0),
87 mem_mode);
88
89 default:
90 break;
91 }
92
93 /* Copy the various flags, fields, and other information. We assume
94 that all fields need copying, and then clear the fields that should
95 not be copied. That is the sensible default behavior, and forces
96 us to explicitly document why we are *not* copying a flag. */
97 x = shallow_copy_rtx (x);
98
99 /* We do not copy the USED flag, which is used as a mark bit during
100 walks over the RTL. */
101 RTX_FLAG (x, used) = 0;
102
103 /* We do not copy FRAME_RELATED for INSNs. */
104 if (INSN_P (x))
105 RTX_FLAG (x, frame_related) = 0;
106
107 fmt = GET_RTX_FORMAT (code);
108 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
109 if (fmt[i] == 'e')
110 XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
111 else if (fmt[i] == 'E' || fmt[i] == 'V')
112 {
113 int j;
114 XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
115 for (j = 0; j < XVECLEN (x, i); j++)
116 XVECEXP (x, i, j)
117 = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
118 }
119
120 #else /* !AUTO_INC_DEC */
121 x = copy_rtx (x);
122 #endif /* !AUTO_INC_DEC */
123
124 return x;
125 }
126
127 /* Auxiliary data structure for propagate_for_debug_stmt. */
128
129 struct rtx_subst_pair
130 {
131 rtx to;
132 bool adjusted;
133 };
134
135 /* DATA points to an rtx_subst_pair. Return the value that should be
136 substituted. */
137
138 static rtx
139 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
140 {
141 struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
142
143 if (!rtx_equal_p (from, old_rtx))
144 return NULL_RTX;
145 if (!pair->adjusted)
146 {
147 pair->adjusted = true;
148 pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
149 pair->to = make_compound_operation (pair->to, SET);
150 return pair->to;
151 }
152 return copy_rtx (pair->to);
153 }
154
155 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
156 and LAST, not including INSN, but including LAST. Also stop at the end
157 of THIS_BASIC_BLOCK. */
158
159 void
160 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src,
161 basic_block this_basic_block)
162 {
163 rtx next, loc, end = NEXT_INSN (BB_END (this_basic_block));
164
165 struct rtx_subst_pair p;
166 p.to = src;
167 p.adjusted = false;
168
169 next = NEXT_INSN (insn);
170 last = NEXT_INSN (last);
171 while (next != last && next != end)
172 {
173 insn = next;
174 next = NEXT_INSN (insn);
175 if (DEBUG_INSN_P (insn))
176 {
177 loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
178 dest, propagate_for_debug_subst, &p);
179 if (loc == INSN_VAR_LOCATION_LOC (insn))
180 continue;
181 INSN_VAR_LOCATION_LOC (insn) = loc;
182 df_insn_rescan (insn);
183 }
184 }
185 }
186
187 /* Initialize DEBUG to an empty list, and clear USED, if given. */
188 void
189 dead_debug_init (struct dead_debug *debug, bitmap used)
190 {
191 debug->head = NULL;
192 debug->used = used;
193 debug->to_rescan = NULL;
194 if (used)
195 bitmap_clear (used);
196 }
197
198 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
199 each reset insn. DEBUG is not otherwise modified. If HEAD is
200 DEBUG->head, DEBUG->head will be set to NULL at the end.
201 Otherwise, entries from DEBUG->head that pertain to reset insns
202 will be removed, and only then rescanned. */
203
204 static void
205 dead_debug_reset_uses (struct dead_debug *debug, struct dead_debug_use *head)
206 {
207 bool got_head = (debug->head == head);
208 bitmap rescan;
209 struct dead_debug_use **tailp = &debug->head;
210 struct dead_debug_use *cur;
211 bitmap_iterator bi;
212 unsigned int uid;
213
214 if (got_head)
215 rescan = NULL;
216 else
217 rescan = BITMAP_ALLOC (NULL);
218
219 while (head)
220 {
221 struct dead_debug_use *next = head->next;
222 rtx insn;
223
224 insn = DF_REF_INSN (head->use);
225 if (!next || DF_REF_INSN (next->use) != insn)
226 {
227 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
228 if (got_head)
229 df_insn_rescan_debug_internal (insn);
230 else
231 bitmap_set_bit (rescan, INSN_UID (insn));
232 if (debug->to_rescan)
233 bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
234 }
235 XDELETE (head);
236 head = next;
237 }
238
239 if (got_head)
240 {
241 debug->head = NULL;
242 return;
243 }
244
245 while ((cur = *tailp))
246 if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
247 {
248 *tailp = cur->next;
249 XDELETE (cur);
250 }
251 else
252 tailp = &cur->next;
253
254 EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
255 {
256 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
257 if (insn_info)
258 df_insn_rescan_debug_internal (insn_info->insn);
259 }
260
261 BITMAP_FREE (rescan);
262 }
263
264 /* Reset all debug insns with pending uses. Release the bitmap in it,
265 unless it is USED. USED must be the same bitmap passed to
266 dead_debug_init. */
267 void
268 dead_debug_finish (struct dead_debug *debug, bitmap used)
269 {
270 if (debug->used != used)
271 BITMAP_FREE (debug->used);
272
273 dead_debug_reset_uses (debug, debug->head);
274
275 if (debug->to_rescan)
276 {
277 bitmap_iterator bi;
278 unsigned int uid;
279
280 EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
281 {
282 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
283 if (insn_info)
284 df_insn_rescan (insn_info->insn);
285 }
286 BITMAP_FREE (debug->to_rescan);
287 }
288 }
289
290 /* Add USE to DEBUG. It must be a dead reference to UREGNO in a debug
291 insn. Create a bitmap for DEBUG as needed. */
292 void
293 dead_debug_add (struct dead_debug *debug, df_ref use, unsigned int uregno)
294 {
295 struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
296
297 newddu->use = use;
298 newddu->next = debug->head;
299 debug->head = newddu;
300
301 if (!debug->used)
302 debug->used = BITMAP_ALLOC (NULL);
303
304 /* ??? If we dealt with split multi-registers below, we should set
305 all registers for the used mode in case of hardware
306 registers. */
307 bitmap_set_bit (debug->used, uregno);
308 }
309
310 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
311 before or after INSN (depending on WHERE), that binds a debug temp
312 to the widest-mode use of UREGNO, if WHERE is *_WITH_REG, or the
313 value stored in UREGNO by INSN otherwise, and replace all uses of
314 UREGNO in DEBUG with uses of the debug temp. INSN must be where
315 UREGNO dies, if WHERE is *_BEFORE_*, or where it is set otherwise.
316 Return the number of debug insns emitted. */
317 int
318 dead_debug_insert_temp (struct dead_debug *debug, unsigned int uregno,
319 rtx insn, enum debug_temp_where where)
320 {
321 struct dead_debug_use **tailp = &debug->head;
322 struct dead_debug_use *cur;
323 struct dead_debug_use *uses = NULL;
324 struct dead_debug_use **usesp = &uses;
325 rtx reg = NULL;
326 rtx breg;
327 rtx dval;
328 rtx bind;
329
330 if (!debug->used || !bitmap_clear_bit (debug->used, uregno))
331 return 0;
332
333 /* Move all uses of uregno from debug->head to uses, setting mode to
334 the widest referenced mode. */
335 while ((cur = *tailp))
336 {
337 if (DF_REF_REGNO (cur->use) == uregno)
338 {
339 *usesp = cur;
340 usesp = &cur->next;
341 *tailp = cur->next;
342 cur->next = NULL;
343 if (!reg
344 || (GET_MODE_BITSIZE (GET_MODE (reg))
345 < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
346 reg = *DF_REF_REAL_LOC (cur->use);
347 }
348 else
349 tailp = &(*tailp)->next;
350 }
351
352 /* We may have dangling bits in debug->used for registers that were part
353 of a multi-register use, one component of which has been reset. */
354 if (reg == NULL)
355 {
356 gcc_checking_assert (!uses);
357 return 0;
358 }
359
360 gcc_checking_assert (uses);
361
362 breg = reg;
363 /* Recover the expression INSN stores in REG. */
364 if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
365 {
366 rtx set = single_set (insn);
367 rtx dest, src;
368
369 if (set)
370 {
371 dest = SET_DEST (set);
372 src = SET_SRC (set);
373 /* Lose if the REG-setting insn is a CALL. */
374 if (GET_CODE (src) == CALL)
375 {
376 while (uses)
377 {
378 cur = uses->next;
379 XDELETE (uses);
380 uses = cur;
381 }
382 return 0;
383 }
384 }
385
386 /* ??? Should we try to extract it from a PARALLEL? */
387 if (!set)
388 breg = NULL;
389 /* Cool, it's the same REG, we can use SRC. */
390 else if (dest == reg)
391 breg = copy_rtx (src);
392 else if (REG_P (dest))
393 {
394 /* Hmm... Something's fishy, we should be setting REG here. */
395 if (REGNO (dest) != REGNO (reg))
396 breg = NULL;
397 /* If we're not overwriting all the hardware registers that
398 setting REG in its mode would, we won't know what to bind
399 the debug temp to. ??? We could bind the debug_expr to a
400 CONCAT or PARALLEL with the split multi-registers, and
401 replace them as we found the corresponding sets. */
402 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
403 && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
404 != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
405 breg = NULL;
406 /* Ok, it's the same (hardware) REG, but with a different
407 mode, so SUBREG it. */
408 else
409 breg = lowpart_subreg (GET_MODE (reg), copy_rtx (src),
410 GET_MODE (dest));
411 }
412 else if (GET_CODE (dest) == SUBREG)
413 {
414 /* We should be setting REG here. Lose. */
415 if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
416 breg = NULL;
417 /* Lose if we're setting something other than the lowpart of
418 REG. */
419 else if (!subreg_lowpart_p (dest))
420 breg = NULL;
421 /* If we're not overwriting all the hardware registers that
422 setting REG in its mode would, we won't know what to bind
423 the debug temp to. */
424 else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
425 && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
426 != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
427 breg = NULL;
428 /* Yay, we can use SRC, just adjust its mode. */
429 else
430 breg = lowpart_subreg (GET_MODE (reg), copy_rtx (src),
431 GET_MODE (dest));
432 }
433 /* Oh well, we're out of luck. */
434 else
435 breg = NULL;
436
437 /* We couldn't figure out the value stored in REG, so reset all
438 of its pending debug uses. */
439 if (!breg)
440 {
441 dead_debug_reset_uses (debug, uses);
442 return 0;
443 }
444 }
445
446 /* If there's a single (debug) use of an otherwise unused REG, and
447 the debug use is not part of a larger expression, then it
448 probably doesn't make sense to introduce a new debug temp. */
449 if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
450 {
451 rtx next = DF_REF_INSN (uses->use);
452
453 if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
454 {
455 XDELETE (uses);
456 return 0;
457 }
458 }
459
460 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
461 dval = make_debug_expr_from_rtl (reg);
462
463 /* Emit a debug bind insn before the insn in which reg dies. */
464 bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
465 DEBUG_EXPR_TREE_DECL (dval), breg,
466 VAR_INIT_STATUS_INITIALIZED);
467
468 if (where == DEBUG_TEMP_AFTER_WITH_REG)
469 bind = emit_debug_insn_after (bind, insn);
470 else
471 bind = emit_debug_insn_before (bind, insn);
472 df_insn_rescan (bind);
473
474 /* Adjust all uses. */
475 while ((cur = uses))
476 {
477 if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
478 *DF_REF_REAL_LOC (cur->use) = dval;
479 else
480 *DF_REF_REAL_LOC (cur->use)
481 = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
482 /* ??? Should we simplify subreg of subreg? */
483 if (debug->to_rescan == NULL)
484 debug->to_rescan = BITMAP_ALLOC (NULL);
485 bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
486 uses = cur->next;
487 XDELETE (cur);
488 }
489
490 return 1;
491 }