gcc/valtrack.c

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