gcc/valtrack.c

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