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   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 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;
 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 = 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 = 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 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
 529    before or after INSN (depending on WHERE), that binds a (possibly
 530    global) debug temp to the widest-mode use of UREGNO, if WHERE is
 531    *_WITH_REG, or the value stored in UREGNO by INSN otherwise, and
 532    replace all uses of UREGNO in DEBUG with uses of the debug temp.
 533    INSN must be where UREGNO dies, if WHERE is *_BEFORE_*, or where it
 534    is set otherwise.  Return the number of debug insns emitted.  */
 535
 536 int
 537 dead_debug_insert_temp (struct dead_debug_local *debug, unsigned int uregno,
 538                         rtx insn, enum debug_temp_where where)
 539 {
 540   struct dead_debug_use **tailp = &debug->head;
 541   struct dead_debug_use *cur;
 542   struct dead_debug_use *uses = NULL;
 543   struct dead_debug_use **usesp = &uses;
 544   rtx reg = NULL_RTX;
 545   rtx breg;
 546   rtx dval = NULL_RTX;
 547   rtx bind;
 548   bool global;
 549
 550   if (!debug->used)
 551     return 0;
 552
 553   global = (debug->global && debug->global->used
 554             && bitmap_bit_p (debug->global->used, uregno));
 555
 556   if (!global && !bitmap_clear_bit (debug->used, uregno))
 557     return 0;
 558
 559   /* Move all uses of uregno from debug->head to uses, setting mode to
 560      the widest referenced mode.  */
 561   while ((cur = *tailp))
 562     {
 563       if (DF_REF_REGNO (cur->use) == uregno)
 564         {
 565           /* If this loc has been changed e.g. to debug_expr already
 566              as part of a multi-register use, just drop it.  */
 567           if (!REG_P (*DF_REF_REAL_LOC (cur->use)))
 568             {
 569               *tailp = cur->next;
 570               XDELETE (cur);
 571               continue;
 572             }
 573           *usesp = cur;
 574           usesp = &cur->next;
 575           *tailp = cur->next;
 576           cur->next = NULL;
 577           if (!reg
 578               || (GET_MODE_BITSIZE (GET_MODE (reg))
 579                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 580             reg = *DF_REF_REAL_LOC (cur->use);
 581         }
 582       else
 583         tailp = &(*tailp)->next;
 584     }
 585
 586   /* We may have dangling bits in debug->used for registers that were part
 587      of a multi-register use, one component of which has been reset.  */
 588   if (reg == NULL)
 589     {
 590       gcc_checking_assert (!uses);
 591       if (!global)
 592         return 0;
 593     }
 594
 595   if (global)
 596     {
 597       if (!reg)
 598         reg = regno_reg_rtx[uregno];
 599       dead_debug_global_entry *entry
 600         = dead_debug_global_find (debug->global, reg);
 601       gcc_checking_assert (entry->reg == reg);
 602       dval = entry->dtemp;
 603       if (!dval)
 604         return 0;
 605     }
 606
 607   gcc_checking_assert (uses || global);
 608
 609   breg = reg;
 610   /* Recover the expression INSN stores in REG.  */
 611   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 612     {
 613       rtx set = single_set (insn);
 614       rtx dest, src;
 615
 616       if (set)
 617         {
 618           dest = SET_DEST (set);
 619           src = SET_SRC (set);
 620           /* Lose if the REG-setting insn is a CALL.  */
 621           if (GET_CODE (src) == CALL)
 622             {
 623               while (uses)
 624                 {
 625                   cur = uses->next;
 626                   XDELETE (uses);
 627                   uses = cur;
 628                 }
 629               return 0;
 630             }
 631         }
 632
 633       /* ??? Should we try to extract it from a PARALLEL?  */
 634       if (!set)
 635         breg = NULL;
 636       /* Cool, it's the same REG, we can use SRC.  */
 637       else if (dest == reg)
 638         breg = cleanup_auto_inc_dec (src, VOIDmode);
 639       else if (REG_P (dest))
 640         {
 641           /* Hmm...  Something's fishy, we should be setting REG here.  */
 642           if (REGNO (dest) != REGNO (reg))
 643             breg = NULL;
 644           /* If we're not overwriting all the hardware registers that
 645              setting REG in its mode would, we won't know what to bind
 646              the debug temp to.  ??? We could bind the debug_expr to a
 647              CONCAT or PARALLEL with the split multi-registers, and
 648              replace them as we found the corresponding sets.  */
 649           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 650                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 651                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 652             breg = NULL;
 653           /* Ok, it's the same (hardware) REG, but with a different
 654              mode, so SUBREG it.  */
 655           else
 656             breg = lowpart_subreg (GET_MODE (reg),
 657                                    cleanup_auto_inc_dec (src, VOIDmode),
 658                                    GET_MODE (dest));
 659         }
 660       else if (GET_CODE (dest) == SUBREG)
 661         {
 662           /* We should be setting REG here.  Lose.  */
 663           if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
 664             breg = NULL;
 665           /* Lose if we're setting something other than the lowpart of
 666              REG.  */
 667           else if (!subreg_lowpart_p (dest))
 668             breg = NULL;
 669           /* If we're not overwriting all the hardware registers that
 670              setting REG in its mode would, we won't know what to bind
 671              the debug temp to.  */
 672           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 673                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 674                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 675             breg = NULL;
 676           /* Yay, we can use SRC, just adjust its mode.  */
 677           else
 678             breg = lowpart_subreg (GET_MODE (reg),
 679                                    cleanup_auto_inc_dec (src, VOIDmode),
 680                                    GET_MODE (dest));
 681         }
 682       /* Oh well, we're out of luck.  */
 683       else
 684         breg = NULL;
 685
 686       /* We couldn't figure out the value stored in REG, so reset all
 687          of its pending debug uses.  */
 688       if (!breg)
 689         {
 690           dead_debug_reset_uses (debug, uses);
 691           return 0;
 692         }
 693     }
 694
 695   /* If there's a single (debug) use of an otherwise unused REG, and
 696      the debug use is not part of a larger expression, then it
 697      probably doesn't make sense to introduce a new debug temp.  */
 698   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 699     {
 700       rtx next = DF_REF_INSN (uses->use);
 701
 702       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 703         {
 704           XDELETE (uses);
 705           return 0;
 706         }
 707     }
 708
 709   if (!global)
 710     /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 711     dval = make_debug_expr_from_rtl (reg);
 712
 713   /* Emit a debug bind insn before the insn in which reg dies.  */
 714   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 715                                DEBUG_EXPR_TREE_DECL (dval), breg,
 716                                VAR_INIT_STATUS_INITIALIZED);
 717
 718   if (where == DEBUG_TEMP_AFTER_WITH_REG
 719       || where == DEBUG_TEMP_AFTER_WITH_REG_FORCE)
 720     bind = emit_debug_insn_after (bind, insn);
 721   else
 722     bind = emit_debug_insn_before (bind, insn);
 723   if (debug->to_rescan == NULL)
 724     debug->to_rescan = BITMAP_ALLOC (NULL);
 725   bitmap_set_bit (debug->to_rescan, INSN_UID (bind));
 726
 727   /* Adjust all uses.  */
 728   while ((cur = uses))
 729     {
 730       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 731         *DF_REF_REAL_LOC (cur->use) = dval;
 732       else
 733         *DF_REF_REAL_LOC (cur->use)
 734           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 735       /* ??? Should we simplify subreg of subreg?  */
 736       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 737       uses = cur->next;
 738       XDELETE (cur);
 739     }
 740
 741   return 1;
 742 }