gcc/valtrack.c

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