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