gcc/valtrack.c

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