gcc/valtrack.c

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