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       bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
 384       gcc_checking_assert (added);
 385
 386       entry = dead_debug_global_insert (debug->global, reg,
 387                                         make_debug_expr_from_rtl (reg));
 388
 389       gcc_checking_assert (entry->dtemp);
 390
 391       /* Tentatively remove the USE from the list.  */
 392       *headp = head->next;
 393
 394       if (!debug->to_rescan)
 395         debug->to_rescan = BITMAP_ALLOC (NULL);
 396
 397       for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
 398            ref = DF_REF_NEXT_REG (ref))
 399         if (DEBUG_INSN_P (DF_REF_INSN (ref)))
 400           {
 401             if (!dead_debug_global_replace_temp (debug->global, ref,
 402                                                  REGNO (reg),
 403                                                  &debug->to_rescan))
 404               {
 405                 rtx insn = DF_REF_INSN (ref);
 406                 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
 407                 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
 408               }
 409           }
 410
 411       for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
 412            ref = DF_REF_NEXT_REG (ref))
 413         if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
 414                                      DEBUG_TEMP_BEFORE_WITH_VALUE))
 415           {
 416             rtx bind;
 417             bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 418                                          DEBUG_EXPR_TREE_DECL (entry->dtemp),
 419                                          gen_rtx_UNKNOWN_VAR_LOC (),
 420                                          VAR_INIT_STATUS_INITIALIZED);
 421             rtx insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
 422             bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
 423           }
 424
 425       entry->dtemp = NULL;
 426       XDELETE (head);
 427     }
 428 }
 429
 430 /* Reset all debug insns with pending uses.  Release the bitmap in it,
 431    unless it is USED.  USED must be the same bitmap passed to
 432    dead_debug_local_init.  */
 433
 434 void
 435 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
 436 {
 437   if (debug->global)
 438     dead_debug_promote_uses (debug);
 439
 440   if (debug->used != used)
 441     BITMAP_FREE (debug->used);
 442
 443   dead_debug_reset_uses (debug, debug->head);
 444
 445   if (debug->to_rescan)
 446     {
 447       bitmap_iterator bi;
 448       unsigned int uid;
 449
 450       EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
 451         {
 452           struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 453           if (insn_info)
 454             df_insn_rescan (insn_info->insn);
 455         }
 456       BITMAP_FREE (debug->to_rescan);
 457     }
 458 }
 459
 460 /* Release GLOBAL->used unless it is the same as USED.  Release the
 461    mapping hash table if it was initialized.  */
 462
 463 void
 464 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
 465 {
 466   if (global->used != used)
 467     BITMAP_FREE (global->used);
 468
 469   if (global->htab.is_created ())
 470     global->htab.dispose ();
 471 }
 472
 473 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
 474    the global substitution list.  USE must be a dead reference to
 475    UREGNO in a debug insn.  Create a bitmap for DEBUG as needed.  */
 476
 477 void
 478 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
 479 {
 480   if (dead_debug_global_replace_temp (debug->global, use, uregno,
 481                                       &debug->to_rescan))
 482     return;
 483
 484   struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
 485
 486   newddu->use = use;
 487   newddu->next = debug->head;
 488   debug->head = newddu;
 489
 490   if (!debug->used)
 491     debug->used = BITMAP_ALLOC (NULL);
 492
 493   /* ??? If we dealt with split multi-registers below, we should set
 494      all registers for the used mode in case of hardware
 495      registers.  */
 496   bitmap_set_bit (debug->used, uregno);
 497 }
 498
 499 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
 500    before or after INSN (depending on WHERE), that binds a (possibly
 501    global) debug temp to the widest-mode use of UREGNO, if WHERE is
 502    *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
 503    replace all uses of UREGNO in DEBUG with uses of the debug temp.
 504    INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
 505    is set otherwise.  Return the number of debug insns emitted.  */
 506
 507 int
 508 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
 509                         rtx insn, enum debug_temp_where where)
 510 {
 511   struct dead_debug_use **tailp = &debug->head;
 512   struct dead_debug_use *cur;
 513   struct dead_debug_use *uses = NULL;
 514   struct dead_debug_use **usesp = &uses;
 515   rtx reg = NULL_RTX;
 516   rtx breg;
 517   rtx dval = NULL_RTX;
 518   rtx bind;
 519   bool global;
 520
 521   if (!debug->used)
 522     return 0;
 523
 524   global = (debug->global && debug->global->used
 525             && bitmap_bit_p (debug->global->used, uregno));
 526
 527   if (!global && !bitmap_clear_bit (debug->used, uregno))
 528     return 0;
 529
 530   /* Move all uses of uregno from debug->head to uses, setting mode to
 531      the widest referenced mode.  */
 532   while ((cur = *tailp))
 533     {
 534       if (DF_REF_REGNO (cur->use) == uregno)
 535         {
 536           /* If this loc has been changed e.g. to debug_expr already
 537              as part of a multi-register use, just drop it.  */
 538           if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
 539             {
 540               *tailp = cur->next;
 541               XDELETE (cur);
 542               continue;
 543             }
 544           *usesp = cur;
 545           usesp = &cur->next;
 546           *tailp = cur->next;
 547           cur->next = NULL;
 548           if (!reg
 549               || (GET_MODE_BITSIZE (GET_MODE (reg))
 550                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 551             reg = *DF_REF_REAL_LOC (cur->use);
 552         }
 553       else
 554         tailp = &(*tailp)->next;
 555     }
 556
 557   /* We may have dangling bits in debug->used for registers that were part
 558      of a multi-register use, one component of which has been reset.  */
 559   if (reg == NULL)
 560     {
 561       gcc_checking_assert (!uses);
 562       if (!global)
 563         return 0;
 564     }
 565
 566   if (global)
 567     {
 568       if (!reg)
 569         reg = regno_reg_rtx[uregno];
 570       dead_debug_global_entry *entry
 571         = dead_debug_global_find (debug->global, reg);
 572       gcc_checking_assert (entry->reg == reg);
 573       dval = entry->dtemp;
 574       if (!dval)
 575         return 0;
 576     }
 577
 578   gcc_checking_assert (uses || global);
 579
 580   breg = reg;
 581   /* Recover the expression INSN stores in REG.  */
 582   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 583     {
 584       rtx set = single_set (insn);
 585       rtx dest, src;
 586
 587       if (set)
 588         {
 589           dest = SET_DEST (set);
 590           src = SET_SRC (set);
 591           /* Lose if the REG-setting insn is a CALL.  */
 592           if (GET_CODE (src) == CALL)
 593             {
 594               while (uses)
 595                 {
 596                   cur = uses->next;
 597                   XDELETE (uses);
 598                   uses = cur;
 599                 }
 600               return 0;
 601             }
 602         }
 603
 604       /* ??? Should we try to extract it from a PARALLEL?  */
 605       if (!set)
 606         breg = NULL;
 607       /* Cool, it's the same REG, we can use SRC.  */
 608       else if (dest == reg)
 609         breg = cleanup_auto_inc_dec (src, VOIDmode);
 610       else if (REG_P (dest))
 611         {
 612           /* Hmm...  Something's fishy, we should be setting REG here.  */
 613           if (REGNO (dest) != REGNO (reg))
 614             breg = NULL;
 615           /* If we're not overwriting all the hardware registers that
 616              setting REG in its mode would, we won't know what to bind
 617              the debug temp to.  ??? We could bind the debug_expr to a
 618              CONCAT or PARALLEL with the split multi-registers, and
 619              replace them as we found the corresponding sets.  */
 620           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 621                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 622                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 623             breg = NULL;
 624           /* Ok, it's the same (hardware) REG, but with a different
 625              mode, so SUBREG it.  */
 626           else
 627             breg = lowpart_subreg (GET_MODE (reg),
 628                                    cleanup_auto_inc_dec (src, VOIDmode),
 629                                    GET_MODE (dest));
 630         }
 631       else if (GET_CODE (dest) == SUBREG)
 632         {
 633           /* We should be setting REG here.  Lose.  */
 634           if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
 635             breg = NULL;
 636           /* Lose if we're setting something other than the lowpart of
 637              REG.  */
 638           else if (!subreg_lowpart_p (dest))
 639             breg = NULL;
 640           /* If we're not overwriting all the hardware registers that
 641              setting REG in its mode would, we won't know what to bind
 642              the debug temp to.  */
 643           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 644                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 645                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 646             breg = NULL;
 647           /* Yay, we can use SRC, just adjust its mode.  */
 648           else
 649             breg = lowpart_subreg (GET_MODE (reg),
 650                                    cleanup_auto_inc_dec (src, VOIDmode),
 651                                    GET_MODE (dest));
 652         }
 653       /* Oh well, we're out of luck.  */
 654       else
 655         breg = NULL;
 656
 657       /* We couldn't figure out the value stored in REG, so reset all
 658          of its pending debug uses.  */
 659       if (!breg)
 660         {
 661           dead_debug_reset_uses (debug, uses);
 662           return 0;
 663         }
 664     }
 665
 666   /* If there's a single (debug) use of an otherwise unused REG, and
 667      the debug use is not part of a larger expression, then it
 668      probably doesn't make sense to introduce a new debug temp.  */
 669   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 670     {
 671       rtx next = DF_REF_INSN (uses->use);
 672
 673       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 674         {
 675           XDELETE (uses);
 676           return 0;
 677         }
 678     }
 679
 680   if (!global)
 681     /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 682     dval = make_debug_expr_from_rtl (reg);
 683
 684   /* Emit a debug bind insn before the insn in which reg dies.  */
 685   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 686                                DEBUG_EXPR_TREE_DECL (dval), breg,
 687                                VAR_INIT_STATUS_INITIALIZED);
 688
 689   if (where == DEBUG_TEMP_AFTER_WITH_REG
 690       || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
 691     bind = emit_debug_insn_after (bind, insn);
 692   else
 693     bind = emit_debug_insn_before (bind, insn);
 694   if (debug->to_rescan == NULL)
 695     debug->to_rescan = BITMAP_ALLOC (NULL);
 696   bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
 697
 698   /* Adjust all uses.  */
 699   while ((cur = uses))
 700     {
 701       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 702         *DF_REF_REAL_LOC (cur->use) = dval;
 703       else
 704         *DF_REF_REAL_LOC (cur->use)
 705           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 706       /* ??? Should we simplify subreg of subreg?  */
 707       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 708       uses = cur->next;
 709       XDELETE (cur);
 710     }
 711
 712   return 1;
 713 }