gcc/valtrack.c

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