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