gcc/valtrack.c

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