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, rtx last, rtx dest, rtx src,
 181                      basic_block this_basic_block)
 182 {
 183   rtx next, loc, end = NEXT_INSN (BB_END (this_basic_block));
 184   rtx (*saved_rtl_hook_no_emit) (enum machine_mode, rtx);
 185
 186   struct rtx_subst_pair p;
 187   p.to = src;
 188   p.adjusted = false;
 189
 190   next = NEXT_INSN (insn);
 191   last = NEXT_INSN (last);
 192   saved_rtl_hook_no_emit = rtl_hooks.gen_lowpart_no_emit;
 193   rtl_hooks.gen_lowpart_no_emit = gen_lowpart_for_debug;
 194   while (next != last && next != end)
 195     {
 196       insn = next;
 197       next = NEXT_INSN (insn);
 198       if (DEBUG_INSN_P (insn))
 199         {
 200           loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
 201                                          dest, propagate_for_debug_subst, &p);
 202           if (loc == INSN_VAR_LOCATION_LOC (insn))
 203             continue;
 204           INSN_VAR_LOCATION_LOC (insn) = loc;
 205           df_insn_rescan (insn);
 206         }
 207     }
 208   rtl_hooks.gen_lowpart_no_emit = saved_rtl_hook_no_emit;
 209 }
 210
 211 /* Initialize DEBUG to an empty list, and clear USED, if given.  */
 212
 213 void
 214 dead_debug_global_init (struct dead_debug_global *debug, bitmap used)
 215 {
 216   debug->used = used;
 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.is_created ())
 269     global->htab.create (31);
 270
 271   dead_debug_global_entry **slot = global->htab.find_slot (&temp_entry, INSERT);
 272   gcc_checking_assert (!*slot);
 273   *slot = XNEW (dead_debug_global_entry);
 274   **slot = temp_entry;
 275   return *slot;
 276 }
 277
 278 /* If UREGNO, referenced by USE, is a pseudo marked as used in GLOBAL,
 279    replace it with with a USE of the debug temp recorded for it, and
 280    return TRUE.  Otherwise, just return FALSE.
 281
 282    If PTO_RESCAN is given, instead of rescanning modified INSNs right
 283    away, add their UIDs to the bitmap, allocating one of *PTO_RESCAN
 284    is NULL.  */
 285
 286 static bool
 287 dead_debug_global_replace_temp (struct dead_debug_global *global,
 288                                 df_ref use, unsigned int uregno,
 289                                 bitmap *pto_rescan)
 290 {
 291   if (!global || uregno < FIRST_PSEUDO_REGISTER
 292       || !global->used
 293       || !REG_P (*DF_REF_REAL_LOC (use))
 294       || REGNO (*DF_REF_REAL_LOC (use)) != uregno
 295       || !bitmap_bit_p (global->used, uregno))
 296     return false;
 297
 298   dead_debug_global_entry *entry
 299     = dead_debug_global_find (global, *DF_REF_REAL_LOC (use));
 300   gcc_checking_assert (GET_CODE (entry->reg) == REG
 301                        && REGNO (entry->reg) == uregno);
 302
 303   if (!entry->dtemp)
 304     return true;
 305
 306   *DF_REF_REAL_LOC (use) = entry->dtemp;
 307   if (!pto_rescan)
 308     df_insn_rescan (DF_REF_INSN (use));
 309   else
 310     {
 311       if (!*pto_rescan)
 312         *pto_rescan = BITMAP_ALLOC (NULL);
 313       bitmap_set_bit (*pto_rescan, INSN_UID (DF_REF_INSN (use)));
 314     }
 315
 316   return true;
 317 }
 318
 319 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
 320    each reset insn.  DEBUG is not otherwise modified.  If HEAD is
 321    DEBUG->head, DEBUG->head will be set to NULL at the end.
 322    Otherwise, entries from DEBUG->head that pertain to reset insns
 323    will be removed, and only then rescanned.  */
 324
 325 static void
 326 dead_debug_reset_uses (struct dead_debug_local *debug,
 327                        struct dead_debug_use *head)
 328 {
 329   bool got_head = (debug->head == head);
 330   bitmap rescan;
 331   struct dead_debug_use **tailp = &debug->head;
 332   struct dead_debug_use *cur;
 333   bitmap_iterator bi;
 334   unsigned int uid;
 335
 336   if (got_head)
 337     rescan = NULL;
 338   else
 339     rescan = BITMAP_ALLOC (NULL);
 340
 341   while (head)
 342     {
 343       struct dead_debug_use *next = head->next;
 344       rtx insn;
 345
 346       insn = DF_REF_INSN (head->use);
 347       if (!next || DF_REF_INSN (next->use) != insn)
 348         {
 349           INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
 350           if (got_head)
 351             df_insn_rescan_debug_internal (insn);
 352           else
 353             bitmap_set_bit (rescan, INSN_UID (insn));
 354           if (debug->to_rescan)
 355             bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
 356         }
 357       XDELETE (head);
 358       head = next;
 359     }
 360
 361   if (got_head)
 362     {
 363       debug->head = NULL;
 364       return;
 365     }
 366
 367   while ((cur = *tailp))
 368     if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
 369       {
 370         *tailp = cur->next;
 371         XDELETE (cur);
 372       }
 373     else
 374       tailp = &cur->next;
 375
 376   EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
 377     {
 378       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 379       if (insn_info)
 380         df_insn_rescan_debug_internal (insn_info->insn);
 381     }
 382
 383   BITMAP_FREE (rescan);
 384 }
 385
 386 /* Promote pending local uses of pseudos in DEBUG to global
 387    substitutions.  Uses of non-pseudos are left alone for
 388    resetting.  */
 389
 390 static void
 391 dead_debug_promote_uses (struct dead_debug_local *debug)
 392 {
 393   for (struct dead_debug_use *head = debug->head, **headp = &debug->head;
 394        head; head = *headp)
 395     {
 396       rtx reg = *DF_REF_REAL_LOC (head->use);
 397       df_ref ref;
 398       dead_debug_global_entry *entry;
 399
 400       if (GET_CODE (reg) != REG
 401           || REGNO (reg) < FIRST_PSEUDO_REGISTER)
 402         {
 403           headp = &head->next;
 404           continue;
 405         }
 406
 407       if (!debug->global->used)
 408         debug->global->used = BITMAP_ALLOC (NULL);
 409
 410       bool added = bitmap_set_bit (debug->global->used, REGNO (reg));
 411       gcc_checking_assert (added);
 412
 413       entry = dead_debug_global_insert (debug->global, reg,
 414                                         make_debug_expr_from_rtl (reg));
 415
 416       gcc_checking_assert (entry->dtemp);
 417
 418       /* Tentatively remove the USE from the list.  */
 419       *headp = head->next;
 420
 421       if (!debug->to_rescan)
 422         debug->to_rescan = BITMAP_ALLOC (NULL);
 423
 424       for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref;
 425            ref = DF_REF_NEXT_REG (ref))
 426         if (DEBUG_INSN_P (DF_REF_INSN (ref)))
 427           {
 428             if (!dead_debug_global_replace_temp (debug->global, ref,
 429                                                  REGNO (reg),
 430                                                  &debug->to_rescan))
 431               {
 432                 rtx insn = DF_REF_INSN (ref);
 433                 INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
 434                 bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
 435               }
 436           }
 437
 438       for (ref = DF_REG_DEF_CHAIN (REGNO (reg)); ref;
 439            ref = DF_REF_NEXT_REG (ref))
 440         if (!dead_debug_insert_temp (debug, REGNO (reg), DF_REF_INSN (ref),
 441                                      DEBUG_TEMP_BEFORE_WITH_VALUE))
 442           {
 443             rtx bind;
 444             bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 445                                          DEBUG_EXPR_TREE_DECL (entry->dtemp),
 446                                          gen_rtx_UNKNOWN_VAR_LOC (),
 447                                          VAR_INIT_STATUS_INITIALIZED);
 448             rtx insn = emit_debug_insn_before (bind, DF_REF_INSN (ref));
 449             bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
 450           }
 451
 452       entry->dtemp = NULL;
 453       XDELETE (head);
 454     }
 455 }
 456
 457 /* Reset all debug insns with pending uses.  Release the bitmap in it,
 458    unless it is USED.  USED must be the same bitmap passed to
 459    dead_debug_local_init.  */
 460
 461 void
 462 dead_debug_local_finish (struct dead_debug_local *debug, bitmap used)
 463 {
 464   if (debug->global)
 465     dead_debug_promote_uses (debug);
 466
 467   if (debug->used != used)
 468     BITMAP_FREE (debug->used);
 469
 470   dead_debug_reset_uses (debug, debug->head);
 471
 472   if (debug->to_rescan)
 473     {
 474       bitmap_iterator bi;
 475       unsigned int uid;
 476
 477       EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
 478         {
 479           struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 480           if (insn_info)
 481             df_insn_rescan (insn_info->insn);
 482         }
 483       BITMAP_FREE (debug->to_rescan);
 484     }
 485 }
 486
 487 /* Release GLOBAL->used unless it is the same as USED.  Release the
 488    mapping hash table if it was initialized.  */
 489
 490 void
 491 dead_debug_global_finish (struct dead_debug_global *global, bitmap used)
 492 {
 493   if (global->used != used)
 494     BITMAP_FREE (global->used);
 495
 496   if (global->htab.is_created ())
 497     global->htab.dispose ();
 498 }
 499
 500 /* Add USE to DEBUG, or substitute it right away if it's a pseudo in
 501    the global substitution list.  USE must be a dead reference to
 502    UREGNO in a debug insn.  Create a bitmap for DEBUG as needed.  */
 503
 504 void
 505 dead_debug_add (struct dead_debug_local *debug, df_ref use, unsigned int uregno)
 506 {
 507   if (dead_debug_global_replace_temp (debug->global, use, uregno,
 508                                       &debug->to_rescan))
 509     return;
 510
 511   struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
 512
 513   newddu->use = use;
 514   newddu->next = debug->head;
 515   debug->head = newddu;
 516
 517   if (!debug->used)
 518     debug->used = BITMAP_ALLOC (NULL);
 519
 520   /* ??? If we dealt with split multi-registers below, we should set
 521      all registers for the used mode in case of hardware
 522      registers.  */
 523   bitmap_set_bit (debug->used, uregno);
 524 }
 525
 526 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
 527    before or after INSN (depending on WHERE), that binds a (possibly
 528    global) debug temp to the widest-mode use of UREGNO, if WHERE is
 529    *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
 530    replace all uses of UREGNO in DEBUG with uses of the debug temp.
 531    INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
 532    is set otherwise.  Return the number of debug insns emitted.  */
 533
 534 int
 535 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
 536                         rtx insn, enum debug_temp_where where)
 537 {
 538   struct dead_debug_use **tailp = &debug->head;
 539   struct dead_debug_use *cur;
 540   struct dead_debug_use *uses = NULL;
 541   struct dead_debug_use **usesp = &uses;
 542   rtx reg = NULL_RTX;
 543   rtx breg;
 544   rtx dval = NULL_RTX;
 545   rtx bind;
 546   bool global;
 547
 548   if (!debug->used)
 549     return 0;
 550
 551   global = (debug->global && debug->global->used
 552             && bitmap_bit_p (debug->global->used, uregno));
 553
 554   if (!global && !bitmap_clear_bit (debug->used, uregno))
 555     return 0;
 556
 557   /* Move all uses of uregno from debug->head to uses, setting mode to
 558      the widest referenced mode.  */
 559   while ((cur = *tailp))
 560     {
 561       if (DF_REF_REGNO (cur->use) == uregno)
 562         {
 563           /* If this loc has been changed e.g. to debug_expr already
 564              as part of a multi-register use, just drop it.  */
 565           if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
 566             {
 567               *tailp = cur->next;
 568               XDELETE (cur);
 569               continue;
 570             }
 571           *usesp = cur;
 572           usesp = &cur->next;
 573           *tailp = cur->next;
 574           cur->next = NULL;
 575           if (!reg
 576               || (GET_MODE_BITSIZE (GET_MODE (reg))
 577                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 578             reg = *DF_REF_REAL_LOC (cur->use);
 579         }
 580       else
 581         tailp = &(*tailp)->next;
 582     }
 583
 584   /* We may have dangling bits in debug->used for registers that were part
 585      of a multi-register use, one component of which has been reset.  */
 586   if (reg == NULL)
 587     {
 588       gcc_checking_assert (!uses);
 589       if (!global)
 590         return 0;
 591     }
 592
 593   if (global)
 594     {
 595       if (!reg)
 596         reg = regno_reg_rtx[uregno];
 597       dead_debug_global_entry *entry
 598         = dead_debug_global_find (debug->global, reg);
 599       gcc_checking_assert (entry->reg == reg);
 600       dval = entry->dtemp;
 601       if (!dval)
 602         return 0;
 603     }
 604
 605   gcc_checking_assert (uses || global);
 606
 607   breg = reg;
 608   /* Recover the expression INSN stores in REG.  */
 609   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 610     {
 611       rtx set = single_set (insn);
 612       rtx dest, src;
 613
 614       if (set)
 615         {
 616           dest = SET_DEST (set);
 617           src = SET_SRC (set);
 618           /* Lose if the REG-setting insn is a CALL.  */
 619           if (GET_CODE (src) == CALL)
 620             {
 621               while (uses)
 622                 {
 623                   cur = uses->next;
 624                   XDELETE (uses);
 625                   uses = cur;
 626                 }
 627               return 0;
 628             }
 629         }
 630
 631       /* ??? Should we try to extract it from a PARALLEL?  */
 632       if (!set)
 633         breg = NULL;
 634       /* Cool, it's the same REG, we can use SRC.  */
 635       else if (dest == reg)
 636         breg = cleanup_auto_inc_dec (src, VOIDmode);
 637       else if (REG_P (dest))
 638         {
 639           /* Hmm...  Something's fishy, we should be setting REG here.  */
 640           if (REGNO (dest) != REGNO (reg))
 641             breg = NULL;
 642           /* If we're not overwriting all the hardware registers that
 643              setting REG in its mode would, we won't know what to bind
 644              the debug temp to.  ??? We could bind the debug_expr to a
 645              CONCAT or PARALLEL with the split multi-registers, and
 646              replace them as we found the corresponding sets.  */
 647           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 648                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 649                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 650             breg = NULL;
 651           /* Ok, it's the same (hardware) REG, but with a different
 652              mode, so SUBREG it.  */
 653           else
 654             breg = lowpart_subreg (GET_MODE (reg),
 655                                    cleanup_auto_inc_dec (src, VOIDmode),
 656                                    GET_MODE (dest));
 657         }
 658       else if (GET_CODE (dest) == SUBREG)
 659         {
 660           /* We should be setting REG here.  Lose.  */
 661           if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
 662             breg = NULL;
 663           /* Lose if we're setting something other than the lowpart of
 664              REG.  */
 665           else if (!subreg_lowpart_p (dest))
 666             breg = NULL;
 667           /* If we're not overwriting all the hardware registers that
 668              setting REG in its mode would, we won't know what to bind
 669              the debug temp to.  */
 670           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 671                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 672                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 673             breg = NULL;
 674           /* Yay, we can use SRC, just adjust its mode.  */
 675           else
 676             breg = lowpart_subreg (GET_MODE (reg),
 677                                    cleanup_auto_inc_dec (src, VOIDmode),
 678                                    GET_MODE (dest));
 679         }
 680       /* Oh well, we're out of luck.  */
 681       else
 682         breg = NULL;
 683
 684       /* We couldn't figure out the value stored in REG, so reset all
 685          of its pending debug uses.  */
 686       if (!breg)
 687         {
 688           dead_debug_reset_uses (debug, uses);
 689           return 0;
 690         }
 691     }
 692
 693   /* If there's a single (debug) use of an otherwise unused REG, and
 694      the debug use is not part of a larger expression, then it
 695      probably doesn't make sense to introduce a new debug temp.  */
 696   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 697     {
 698       rtx next = DF_REF_INSN (uses->use);
 699
 700       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 701         {
 702           XDELETE (uses);
 703           return 0;
 704         }
 705     }
 706
 707   if (!global)
 708     /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 709     dval = make_debug_expr_from_rtl (reg);
 710
 711   /* Emit a debug bind insn before the insn in which reg dies.  */
 712   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 713                                DEBUG_EXPR_TREE_DECL (dval), breg,
 714                                VAR_INIT_STATUS_INITIALIZED);
 715
 716   if (where == DEBUG_TEMP_AFTER_WITH_REG
 717       || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
 718     bind = emit_debug_insn_after (bind, insn);
 719   else
 720     bind = emit_debug_insn_before (bind, insn);
 721   if (debug->to_rescan == NULL)
 722     debug->to_rescan = BITMAP_ALLOC (NULL);
 723   bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
 724
 725   /* Adjust all uses.  */
 726   while ((cur = uses))
 727     {
 728       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 729         *DF_REF_REAL_LOC (cur->use) = dval;
 730       else
 731         *DF_REF_REAL_LOC (cur->use)
 732           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 733       /* ??? Should we simplify subreg of subreg?  */
 734       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 735       uses = cur->next;
 736       XDELETE (cur);
 737     }
 738
 739   return 1;
 740 }