Branch data Line data Source code
1 : : /* Infrastructure for tracking user variable locations and values
2 : : throughout compilation.
3 : : Copyright (C) 2010-2025 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 "backend.h"
26 : : #include "rtl.h"
27 : : #include "df.h"
28 : : #include "valtrack.h"
29 : : #include "regs.h"
30 : : #include "memmodel.h"
31 : : #include "emit-rtl.h"
32 : : #include "rtl-iter.h"
33 : :
34 : : /* gen_lowpart_no_emit hook implementation for DEBUG_INSNs. In DEBUG_INSNs,
35 : : all lowpart SUBREGs are valid, despite what the machine requires for
36 : : instructions. */
37 : :
38 : : static rtx
39 : 302 : gen_lowpart_for_debug (machine_mode mode, rtx x)
40 : : {
41 : 302 : rtx result = gen_lowpart_if_possible (mode, x);
42 : 302 : if (result)
43 : : return result;
44 : :
45 : 4 : if (GET_MODE (x) != VOIDmode)
46 : 4 : return gen_rtx_raw_SUBREG (mode, x,
47 : : subreg_lowpart_offset (mode, GET_MODE (x)));
48 : :
49 : : return NULL_RTX;
50 : : }
51 : :
52 : : /* Replace auto-increment addressing modes with explicit operations to access
53 : : the same addresses without modifying the corresponding registers. */
54 : :
55 : : static rtx
56 : 1056538 : cleanup_auto_inc_dec (rtx src, machine_mode mem_mode ATTRIBUTE_UNUSED)
57 : : {
58 : 1056538 : rtx x = src;
59 : :
60 : 1056538 : const RTX_CODE code = GET_CODE (x);
61 : 1056538 : int i;
62 : 1056538 : const char *fmt;
63 : :
64 : 1056538 : switch (code)
65 : : {
66 : : case REG:
67 : : CASE_CONST_ANY:
68 : : case SYMBOL_REF:
69 : : case CODE_LABEL:
70 : : case PC:
71 : : case SCRATCH:
72 : : /* SCRATCH must be shared because they represent distinct values. */
73 : : return x;
74 : 0 : case CLOBBER:
75 : : /* Share clobbers of hard registers, but do not share pseudo reg
76 : : clobbers or clobbers of hard registers that originated as pseudos.
77 : : This is needed to allow safe register renaming. */
78 : 0 : if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
79 : 0 : && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0)))
80 : : return x;
81 : : break;
82 : :
83 : 1478 : case CONST:
84 : 1478 : if (shared_const_p (x))
85 : : return x;
86 : : break;
87 : :
88 : 107453 : case MEM:
89 : 107453 : mem_mode = GET_MODE (x);
90 : 107453 : break;
91 : :
92 : 0 : case PRE_INC:
93 : 0 : case PRE_DEC:
94 : 0 : {
95 : 0 : gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
96 : 0 : poly_int64 offset = GET_MODE_SIZE (mem_mode);
97 : 0 : if (code == PRE_DEC)
98 : 0 : offset = -offset;
99 : 0 : return gen_rtx_PLUS (GET_MODE (x),
100 : : cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
101 : : gen_int_mode (offset, GET_MODE (x)));
102 : : }
103 : :
104 : 0 : case POST_INC:
105 : 0 : case POST_DEC:
106 : 0 : case PRE_MODIFY:
107 : 0 : case POST_MODIFY:
108 : 0 : return cleanup_auto_inc_dec (code == PRE_MODIFY
109 : : ? XEXP (x, 1) : XEXP (x, 0),
110 : 0 : mem_mode);
111 : :
112 : : default:
113 : : break;
114 : : }
115 : :
116 : : /* Copy the various flags, fields, and other information. We assume
117 : : that all fields need copying, and then clear the fields that should
118 : : not be copied. That is the sensible default behavior, and forces
119 : : us to explicitly document why we are *not* copying a flag. */
120 : 348529 : x = shallow_copy_rtx (x);
121 : :
122 : : /* We do not copy FRAME_RELATED for INSNs. */
123 : 348529 : if (INSN_P (x))
124 : 0 : RTX_FLAG (x, frame_related) = 0;
125 : :
126 : 348529 : fmt = GET_RTX_FORMAT (code);
127 : 1037644 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
128 : 689115 : if (fmt[i] == 'e')
129 : 570670 : XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
130 : 118445 : else if (fmt[i] == 'E' || fmt[i] == 'V')
131 : : {
132 : 382 : int j;
133 : 382 : XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
134 : 768 : for (j = 0; j < XVECLEN (x, i); j++)
135 : 386 : XVECEXP (x, i, j)
136 : 386 : = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
137 : : }
138 : :
139 : : return x;
140 : : }
141 : :
142 : : /* Auxiliary data structure for propagate_for_debug_stmt. */
143 : :
144 : : struct rtx_subst_pair
145 : : {
146 : : rtx to;
147 : : bool adjusted;
148 : : rtx_insn *insn;
149 : : };
150 : :
151 : : /* DATA points to an rtx_subst_pair. Return the value that should be
152 : : substituted. */
153 : :
154 : : static rtx
155 : 3069246 : propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
156 : : {
157 : 3069246 : struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
158 : :
159 : 3069246 : if (!rtx_equal_p (from, old_rtx))
160 : : return NULL_RTX;
161 : 236629 : if (!pair->adjusted)
162 : : {
163 : 193060 : pair->adjusted = true;
164 : 193060 : pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
165 : 193060 : pair->to = make_compound_operation (pair->to, SET);
166 : : /* Avoid propagation from growing DEBUG_INSN expressions too much. */
167 : 193060 : int cnt = 0;
168 : 193060 : subrtx_iterator::array_type array;
169 : 595157 : FOR_EACH_SUBRTX (iter, array, pair->to, ALL)
170 : 423708 : if (REG_P (*iter) && ++cnt > 1)
171 : : {
172 : 21611 : rtx dval = make_debug_expr_from_rtl (old_rtx);
173 : 21611 : rtx to = pair->to;
174 : 21611 : if (volatile_insn_p (to))
175 : 0 : to = gen_rtx_UNKNOWN_VAR_LOC ();
176 : : /* Emit a debug bind insn. */
177 : 21611 : rtx bind
178 : 21611 : = gen_rtx_VAR_LOCATION (GET_MODE (old_rtx),
179 : : DEBUG_EXPR_TREE_DECL (dval), to,
180 : : VAR_INIT_STATUS_INITIALIZED);
181 : 21611 : rtx_insn *bind_insn = emit_debug_insn_before (bind, pair->insn);
182 : 21611 : df_insn_rescan (bind_insn);
183 : 21611 : pair->to = dval;
184 : 21611 : break;
185 : : }
186 : 193060 : return pair->to;
187 : 193060 : }
188 : 43569 : return copy_rtx (pair->to);
189 : : }
190 : :
191 : : /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
192 : : and LAST, not including INSN, but including LAST. Also stop at the end
193 : : of THIS_BASIC_BLOCK. */
194 : :
195 : : void
196 : 2238149 : propagate_for_debug (rtx_insn *insn, rtx_insn *last, rtx dest, rtx src,
197 : : basic_block this_basic_block)
198 : : {
199 : 2238149 : rtx_insn *next, *end = NEXT_INSN (BB_END (this_basic_block));
200 : 2238149 : rtx loc;
201 : 2238149 : rtx (*saved_rtl_hook_no_emit) (machine_mode, rtx);
202 : :
203 : 2238149 : struct rtx_subst_pair p;
204 : 2238149 : p.to = src;
205 : 2238149 : p.adjusted = false;
206 : 2238149 : p.insn = NEXT_INSN (insn);
207 : :
208 : 2238149 : next = NEXT_INSN (insn);
209 : 2238149 : last = NEXT_INSN (last);
210 : 2238149 : saved_rtl_hook_no_emit = rtl_hooks.gen_lowpart_no_emit;
211 : 2238149 : rtl_hooks.gen_lowpart_no_emit = gen_lowpart_for_debug;
212 : 8749465 : while (next != last && next != end)
213 : : {
214 : 6511316 : insn = next;
215 : 6511316 : next = NEXT_INSN (insn);
216 : 6511316 : if (DEBUG_BIND_INSN_P (insn))
217 : : {
218 : 1724267 : loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
219 : : dest, propagate_for_debug_subst, &p);
220 : 1724267 : if (loc == INSN_VAR_LOCATION_LOC (insn))
221 : 1487960 : continue;
222 : 236307 : if (volatile_insn_p (loc))
223 : 0 : loc = gen_rtx_UNKNOWN_VAR_LOC ();
224 : 236307 : INSN_VAR_LOCATION_LOC (insn) = loc;
225 : 236307 : df_insn_rescan (insn);
226 : : }
227 : : }
228 : 2238149 : rtl_hooks.gen_lowpart_no_emit = saved_rtl_hook_no_emit;
229 : 2238149 : }
230 : :
231 : : /* Initialize DEBUG to an empty list, and clear USED, if given. */
232 : :
233 : : void
234 : 10010072 : dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
235 : : {
236 : 10010072 : debug->used = used;
237 : 10010072 : debug->htab = NULL;
238 : 10010072 : if (used)
239 : 0 : bitmap_clear (used);
240 : 10010072 : }
241 : :
242 : : /* Initialize DEBUG to an empty list, and clear USED, if given. Link
243 : : back to GLOBAL, if given, and bring in used bits from it. */
244 : :
245 : : void
246 : 390797915 : dead_debug_local_init (struct dead_debug_local *debug, bitmap used,
247 : : struct dead_debug_global *global)
248 : : {
249 : 390797915 : if (!used && global && global->used)
250 : 3117409 : used = BITMAP_ALLOC (NULL);
251 : :
252 : 390797915 : debug->head = NULL;
253 : 390797915 : debug->global = global;
254 : 390797915 : debug->used = used;
255 : 390797915 : debug->to_rescan = NULL;
256 : :
257 : 390797915 : if (used)
258 : : {
259 : 3117409 : if (global && global->used)
260 : 3117409 : bitmap_copy (used, global->used);
261 : : else
262 : 0 : bitmap_clear (used);
263 : : }
264 : 390797915 : }
265 : :
266 : : /* Locate the entry for REG in GLOBAL->htab. */
267 : :
268 : : static dead_debug_global_entry *
269 : 1457833 : dead_debug_global_find (struct dead_debug_global *global, rtx reg)
270 : : {
271 : 1457833 : dead_debug_global_entry temp_entry;
272 : 1457833 : temp_entry.reg = reg;
273 : :
274 : 1457833 : dead_debug_global_entry *entry = global->htab->find (&temp_entry);
275 : 1457833 : gcc_checking_assert (entry && entry->reg == temp_entry.reg);
276 : :
277 : 1457833 : return entry;
278 : : }
279 : :
280 : : /* Insert an entry mapping REG to DTEMP in GLOBAL->htab. */
281 : :
282 : : static dead_debug_global_entry *
283 : 128333 : dead_debug_global_insert (struct dead_debug_global *global, rtx reg, rtx dtemp)
284 : : {
285 : 128333 : dead_debug_global_entry temp_entry;
286 : 128333 : temp_entry.reg = reg;
287 : 128333 : temp_entry.dtemp = dtemp;
288 : :
289 : 128333 : if (!global->htab)
290 : 72331 : global->htab = new hash_table<dead_debug_hash_descr> (31);
291 : :
292 : 128333 : dead_debug_global_entry **slot = global->htab->find_slot (&temp_entry,
293 : : INSERT);
294 : 128333 : gcc_checking_assert (!*slot);
295 : 128333 : *slot = XNEW (dead_debug_global_entry);
296 : 128333 : **slot = temp_entry;
297 : 128333 : return *slot;
298 : : }
299 : :
300 : : /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
301 : : replace it with a USE of the debug temp recorded for it, and
302 : : return TRUE. Otherwise, just return FALSE.
303 : :
304 : : If PTO_RESCAN is given, instead of rescanning modified INSNs right
305 : : away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
306 : : is NULL. */
307 : :
308 : : static bool
309 : 1432769 : dead_debug_global_replace_temp (struct dead_debug_global *global,
310 : : df_ref use, unsigned int uregno,
311 : : bitmap *pto_rescan)
312 : : {
313 : 1432769 : if (!global || uregno < FIRST_PSEUDO_REGISTER
314 : 1195158 : || !global->used
315 : 1005083 : || !REG_P (*DF_REF_REAL_LOC (use))
316 : 1005074 : || REGNO (*DF_REF_REAL_LOC (use)) != uregno
317 : 2437843 : || !bitmap_bit_p (global->used, uregno))
318 : 508236 : return false;
319 : :
320 : 924533 : dead_debug_global_entry *entry
321 : 924533 : = dead_debug_global_find (global, *DF_REF_REAL_LOC (use));
322 : 924533 : gcc_checking_assert (GET_CODE (entry->reg) == REG
323 : : && REGNO (entry->reg) == uregno);
324 : :
325 : 924533 : if (!entry->dtemp)
326 : : return true;
327 : :
328 : 924530 : *DF_REF_REAL_LOC (use) = entry->dtemp;
329 : 924530 : if (!pto_rescan)
330 : 0 : df_insn_rescan (DF_REF_INSN (use));
331 : : else
332 : : {
333 : 924530 : if (!*pto_rescan)
334 : 0 : *pto_rescan = BITMAP_ALLOC (NULL);
335 : 924530 : bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
336 : : }
337 : :
338 : : return true;
339 : : }
340 : :
341 : : /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
342 : : each reset insn. DEBUG is not otherwise modified. If HEAD is
343 : : DEBUG->head, DEBUG->head will be set to NULL at the end.
344 : : Otherwise, entries from DEBUG->head that pertain to reset insns
345 : : will be removed, and only then rescanned. */
346 : :
347 : : static void
348 : 390804609 : dead_debug_reset_uses (struct dead_debug_local *debug,
349 : : struct dead_debug_use *head)
350 : : {
351 : 390804609 : bool got_head = (debug->head == head);
352 : 390804609 : bitmap rescan;
353 : 390804609 : struct dead_debug_use **tailp = &debug->head;
354 : 390804609 : struct dead_debug_use *cur;
355 : 390804609 : bitmap_iterator bi;
356 : 390804609 : unsigned int uid;
357 : :
358 : 390804609 : if (got_head)
359 : 390804609 : rescan = NULL;
360 : : else
361 : 1613 : rescan = BITMAP_ALLOC (NULL);
362 : :
363 : 390942319 : while (head)
364 : : {
365 : 137710 : struct dead_debug_use *next = head->next;
366 : 137710 : rtx_insn *insn;
367 : :
368 : 137710 : insn = DF_REF_INSN (head->use);
369 : 137710 : if (!next || DF_REF_INSN (next->use) != insn)
370 : : {
371 : 135332 : INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
372 : 135332 : if (got_head)
373 : 133772 : df_insn_rescan_debug_internal (insn);
374 : : else
375 : 1560 : bitmap_set_bit (rescan, INSN_UID (insn));
376 : 135332 : if (debug->to_rescan)
377 : 3254 : bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
378 : : }
379 : 137710 : XDELETE (head);
380 : 137710 : head = next;
381 : : }
382 : :
383 : 390804609 : if (got_head)
384 : : {
385 : 390802996 : debug->head = NULL;
386 : 390802996 : return;
387 : : }
388 : :
389 : 1991 : while ((cur = *tailp))
390 : 378 : if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
391 : : {
392 : 25 : *tailp = cur->next;
393 : 25 : XDELETE (cur);
394 : : }
395 : : else
396 : 353 : tailp = &cur->next;
397 : :
398 : 3173 : EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
399 : : {
400 : 1560 : struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
401 : 1560 : if (insn_info)
402 : 1560 : df_insn_rescan_debug_internal (insn_info->insn);
403 : : }
404 : :
405 : 1613 : BITMAP_FREE (rescan);
406 : : }
407 : :
408 : : /* Promote pending local uses of pseudos in DEBUG to global
409 : : substitutions. Uses of non-pseudos are left alone for
410 : : resetting. */
411 : :
412 : : static void
413 : 177249183 : dead_debug_promote_uses (struct dead_debug_local *debug)
414 : : {
415 : 177249183 : for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
416 : 177380636 : head; head = *headp)
417 : : {
418 : 131453 : rtx reg = *DF_REF_REAL_LOC (head->use);
419 : 131453 : df_ref ref;
420 : 131453 : dead_debug_global_entry *entry;
421 : :
422 : 134573 : if (GET_CODE (reg) != REG
423 : 131453 : || REGNO (reg) < FIRST_PSEUDO_REGISTER)
424 : : {
425 : 3120 : headp = &head->next;
426 : 3120 : continue;
427 : : }
428 : :
429 : 128333 : if (!debug->global->used)
430 : 72331 : debug->global->used = BITMAP_ALLOC (NULL);
431 : :
432 : 128333 : bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
433 : 128333 : gcc_checking_assert (added);
434 : :
435 : 128333 : entry = dead_debug_global_insert (debug->global, reg,
436 : : make_debug_expr_from_rtl (reg));
437 : :
438 : 128333 : gcc_checking_assert (entry->dtemp);
439 : :
440 : : /* Tentatively remove the USE from the list. */
441 : 128333 : *headp = head->next;
442 : :
443 : 128333 : if (!debug->to_rescan)
444 : 110416 : debug->to_rescan = BITMAP_ALLOC (NULL);
445 : :
446 : 1806622 : for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
447 : 1678289 : ref = DF_REF_NEXT_REG (ref))
448 : 1678289 : if (DEBUG_INSN_P (DF_REF_INSN (ref)))
449 : : {
450 : 924539 : if (!dead_debug_global_replace_temp (debug->global, ref,
451 : : REGNO (reg),
452 : : &debug->to_rescan))
453 : : {
454 : 9 : rtx_insn *insn = DF_REF_INSN (ref);
455 : 9 : INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
456 : 9 : bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
457 : : }
458 : : }
459 : :
460 : 405222 : for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
461 : 276889 : ref = DF_REF_NEXT_REG (ref))
462 : 276889 : if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
463 : : DEBUG_TEMP_BEFORE_WITH_VALUE))
464 : : {
465 : 5231 : rtx bind;
466 : 5231 : bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
467 : 5231 : DEBUG_EXPR_TREE_DECL (entry->dtemp),
468 : : gen_rtx_UNKNOWN_VAR_LOC (),
469 : : VAR_INIT_STATUS_INITIALIZED);
470 : 5231 : rtx_insn *insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
471 : 5231 : bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
472 : : }
473 : :
474 : 128333 : entry->dtemp = NULL;
475 : 128333 : XDELETE (head);
476 : : }
477 : 177249183 : }
478 : :
479 : : /* Reset all debug insns with pending uses. Release the bitmap in it,
480 : : unless it is USED. USED must be the same bitmap passed to
481 : : dead_debug_local_init. */
482 : :
483 : : void
484 : 390797915 : dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
485 : : {
486 : 390797915 : if (debug->global)
487 : 177249183 : dead_debug_promote_uses (debug);
488 : :
489 : 390797915 : if (debug->used != used)
490 : 3375127 : BITMAP_FREE (debug->used);
491 : :
492 : 390797915 : dead_debug_reset_uses (debug, debug->head);
493 : :
494 : 390797915 : if (debug->to_rescan)
495 : : {
496 : 203666 : bitmap_iterator bi;
497 : 203666 : unsigned int uid;
498 : :
499 : 1669955 : EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
500 : : {
501 : 1466289 : struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
502 : 1466289 : if (insn_info)
503 : 1466289 : df_insn_rescan (insn_info->insn);
504 : : }
505 : 203666 : BITMAP_FREE (debug->to_rescan);
506 : : }
507 : 390797915 : }
508 : :
509 : : /* Release GLOBAL->used unless it is the same as USED. Release the
510 : : mapping hash table if it was initialized. */
511 : :
512 : : void
513 : 10010072 : dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
514 : : {
515 : 10010072 : if (global->used != used)
516 : 72331 : BITMAP_FREE (global->used);
517 : :
518 : 10010072 : delete global->htab;
519 : 10010072 : global->htab = NULL;
520 : 10010072 : }
521 : :
522 : : /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
523 : : the global substitution list. USE must be a dead reference to
524 : : UREGNO in a debug insn. Create a bitmap for DEBUG as needed. */
525 : :
526 : : void
527 : 508230 : dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
528 : : {
529 : 508230 : if (dead_debug_global_replace_temp (debug->global, use, uregno,
530 : : &debug->to_rescan))
531 : : return;
532 : :
533 : 508227 : struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
534 : :
535 : 508227 : newddu->use = use;
536 : 508227 : newddu->next = debug->head;
537 : 508227 : debug->head = newddu;
538 : :
539 : 508227 : if (!debug->used)
540 : 257718 : debug->used = BITMAP_ALLOC (NULL);
541 : :
542 : : /* ??? If we dealt with split multi-registers below, we should set
543 : : all registers for the used mode in case of hardware
544 : : registers. */
545 : 508227 : bitmap_set_bit (debug->used, uregno);
546 : : }
547 : :
548 : : /* Like lowpart_subreg, but if a subreg is not valid for machine, force
549 : : it anyway - for use in debug insns. */
550 : :
551 : : static rtx
552 : 1666 : debug_lowpart_subreg (machine_mode outer_mode, rtx expr,
553 : : machine_mode inner_mode)
554 : : {
555 : 1666 : if (inner_mode == VOIDmode)
556 : 0 : inner_mode = GET_MODE (expr);
557 : 1666 : poly_int64 offset = subreg_lowpart_offset (outer_mode, inner_mode);
558 : 1666 : rtx ret = simplify_gen_subreg (outer_mode, expr, inner_mode, offset);
559 : 1666 : if (ret)
560 : : return ret;
561 : 6 : if (GET_MODE (expr) != VOIDmode)
562 : 4 : return gen_rtx_raw_SUBREG (outer_mode, expr, offset);
563 : : return NULL_RTX;
564 : : }
565 : :
566 : : /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
567 : : before or after INSN (depending on WHERE), that binds a (possibly
568 : : global) debug temp to the widest-mode use of UREGNO, if WHERE is
569 : : *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
570 : : replace all uses of UREGNO in DEBUG with uses of the debug temp.
571 : : INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
572 : : is set otherwise. Return the number of debug insns emitted. */
573 : :
574 : : int
575 : 925041266 : dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
576 : : rtx_insn *insn, enum debug_temp_where where)
577 : : {
578 : 925041266 : struct dead_debug_use **tailp = &debug->head;
579 : 925041266 : struct dead_debug_use *cur;
580 : 925041266 : struct dead_debug_use *uses = NULL;
581 : 925041266 : struct dead_debug_use **usesp = &uses;
582 : 925041266 : rtx reg = NULL_RTX;
583 : 925041266 : rtx breg;
584 : 925041266 : rtx dval = NULL_RTX;
585 : 925041266 : rtx bind;
586 : 925041266 : bool global;
587 : :
588 : 925041266 : if (!debug->used)
589 : : return 0;
590 : :
591 : 79300193 : global = (debug->global && debug->global->used
592 : 155397889 : && bitmap_bit_p (debug->global->used, uregno));
593 : :
594 : 78609653 : if (!global && !bitmap_clear_bit (debug->used, uregno))
595 : : return 0;
596 : :
597 : : /* Move all uses of uregno from debug->head to uses, setting mode to
598 : : the widest referenced mode. */
599 : 1137949 : while ((cur = *tailp))
600 : : {
601 : 461278 : if (DF_REF_REGNO (cur->use) == uregno)
602 : : {
603 : : /* If this loc has been changed e.g. to debug_expr already
604 : : as part of a multi-register use, just drop it. */
605 : 243725 : if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
606 : : {
607 : 49929 : *tailp = cur->next;
608 : 49929 : XDELETE (cur);
609 : 49929 : continue;
610 : : }
611 : 193796 : *usesp = cur;
612 : 193796 : usesp = &cur->next;
613 : 193796 : *tailp = cur->next;
614 : 193796 : cur->next = NULL;
615 : : /* "may" rather than "must" because we want (for example)
616 : : N V4SFs to win over plain V4SF even though N might be 1. */
617 : 193796 : rtx candidate = *DF_REF_REAL_LOC (cur->use);
618 : 193796 : if (!reg
619 : 244296 : || maybe_lt (GET_MODE_BITSIZE (GET_MODE (reg)),
620 : 101000 : GET_MODE_BITSIZE (GET_MODE (candidate))))
621 : : reg = candidate;
622 : : }
623 : : else
624 : 217553 : tailp = &(*tailp)->next;
625 : : }
626 : :
627 : : /* We may have dangling bits in debug->used for registers that were part
628 : : of a multi-register use, one component of which has been reset. */
629 : 676671 : if (reg == NULL)
630 : : {
631 : 533375 : gcc_checking_assert (!uses);
632 : 533375 : if (!global)
633 : : return 0;
634 : : }
635 : :
636 : 143296 : if (global)
637 : : {
638 : 533300 : if (!reg)
639 : 533300 : reg = regno_reg_rtx[uregno];
640 : 533300 : dead_debug_global_entry *entry
641 : 533300 : = dead_debug_global_find (debug->global, reg);
642 : 533300 : gcc_checking_assert (entry->reg == reg);
643 : 533300 : dval = entry->dtemp;
644 : 533300 : if (!dval)
645 : : return 0;
646 : : }
647 : :
648 : 420185 : gcc_checking_assert (uses || global);
649 : :
650 : 420185 : breg = reg;
651 : : /* Recover the expression INSN stores in REG. */
652 : 420185 : if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
653 : : {
654 : 299114 : rtx set = single_set (insn);
655 : 299114 : rtx dest, src;
656 : :
657 : 299114 : if (set)
658 : : {
659 : 294382 : dest = SET_DEST (set);
660 : 294382 : src = SET_SRC (set);
661 : : /* Reset uses if the REG-setting insn is a CALL. Asm in
662 : : DEBUG_INSN is never useful, we can't emit debug info for
663 : : that. And for volatile_insn_p, it is actually harmful -
664 : : DEBUG_INSNs shouldn't have any side-effects. */
665 : 294381 : if (GET_CODE (src) == CALL || GET_CODE (src) == ASM_OPERANDS
666 : 588717 : || volatile_insn_p (src))
667 : : set = NULL_RTX;
668 : : }
669 : :
670 : : /* ??? Should we try to extract it from a PARALLEL? */
671 : 294335 : if (!set)
672 : : breg = NULL;
673 : : /* Cool, it's the same REG, we can use SRC. */
674 : 294335 : else if (dest == reg)
675 : 290888 : breg = cleanup_auto_inc_dec (src, VOIDmode);
676 : 3447 : else if (REG_P (dest))
677 : : {
678 : : /* Hmm... Something's fishy, we should be setting REG here. */
679 : 2249 : if (REGNO (dest) != REGNO (reg))
680 : : breg = NULL;
681 : : /* If we're not overwriting all the hardware registers that
682 : : setting REG in its mode would, we won't know what to bind
683 : : the debug temp to. ??? We could bind the debug_expr to a
684 : : CONCAT or PARALLEL with the split multi-registers, and
685 : : replace them as we found the corresponding sets. */
686 : 1066 : else if (REG_NREGS (reg) != REG_NREGS (dest))
687 : : breg = NULL;
688 : : /* Ok, it's the same (hardware) REG, but with a different
689 : : mode, so SUBREG it. */
690 : : else
691 : 873 : breg = debug_lowpart_subreg (GET_MODE (reg),
692 : : cleanup_auto_inc_dec (src, VOIDmode),
693 : 873 : GET_MODE (dest));
694 : : }
695 : 1198 : else if (GET_CODE (dest) == SUBREG)
696 : : {
697 : : /* We should be setting REG here. Lose. */
698 : 1193 : if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
699 : : breg = NULL;
700 : : /* Lose if we're setting something other than the lowpart of
701 : : REG. */
702 : 1193 : else if (!subreg_lowpart_p (dest))
703 : : breg = NULL;
704 : : /* If we're not overwriting all the hardware registers that
705 : : setting REG in its mode would, we won't know what to bind
706 : : the debug temp to. */
707 : 661 : else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
708 : 661 : && (REG_NREGS (reg)
709 : 0 : != hard_regno_nregs (REGNO (reg), GET_MODE (dest))))
710 : : breg = NULL;
711 : : /* Yay, we can use SRC, just adjust its mode. */
712 : : else
713 : 661 : breg = debug_lowpart_subreg (GET_MODE (reg),
714 : : cleanup_auto_inc_dec (src, VOIDmode),
715 : 661 : GET_MODE (dest));
716 : : }
717 : : /* Oh well, we're out of luck. */
718 : : else
719 : : breg = NULL;
720 : :
721 : : /* We couldn't figure out the value stored in REG, so reset all
722 : : of its pending debug uses. */
723 : 292422 : if (!breg)
724 : : {
725 : 6694 : dead_debug_reset_uses (debug, uses);
726 : 6694 : return 0;
727 : : }
728 : : }
729 : :
730 : : /* If there's a single (debug) use of an otherwise unused REG, and
731 : : the debug use is not part of a larger expression, then it
732 : : probably doesn't make sense to introduce a new debug temp. */
733 : 413491 : if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
734 : : {
735 : 29804 : rtx_insn *next = DF_REF_INSN (uses->use);
736 : :
737 : 29804 : if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
738 : : {
739 : 27706 : XDELETE (uses);
740 : 27706 : return 0;
741 : : }
742 : : }
743 : :
744 : 385785 : if (!global)
745 : : /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
746 : 114127 : dval = make_debug_expr_from_rtl (reg);
747 : :
748 : : /* Emit a debug bind insn before the insn in which reg dies. */
749 : 385785 : bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
750 : : DEBUG_EXPR_TREE_DECL (dval), breg,
751 : : VAR_INIT_STATUS_INITIALIZED);
752 : :
753 : 385785 : if (where == DEBUG_TEMP_AFTER_WITH_REG
754 : 385785 : || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
755 : 76690 : bind = emit_debug_insn_after (bind, insn);
756 : : else
757 : 309095 : bind = emit_debug_insn_before (bind, insn);
758 : 385785 : if (debug->to_rescan == NULL)
759 : 93250 : debug->to_rescan = BITMAP_ALLOC (NULL);
760 : 385785 : bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
761 : :
762 : : /* Adjust all uses. */
763 : 936094 : while ((cur = uses))
764 : : {
765 : 164524 : if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
766 : 164392 : *DF_REF_REAL_LOC (cur->use) = dval;
767 : : else
768 : 132 : *DF_REF_REAL_LOC (cur->use)
769 : 132 : = debug_lowpart_subreg (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval,
770 : 132 : GET_MODE (dval));
771 : : /* ??? Should we simplify subreg of subreg? */
772 : 164524 : bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
773 : 164524 : uses = cur->next;
774 : 164524 : XDELETE (cur);
775 : : }
776 : :
777 : : return 1;
778 : : }
|
