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