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