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