gcc/valtrack.c

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