gcc/valtrack.c

   1 /* Infrastructure for tracking user variable locations and values
   2    throughout compilation.
   3    Copyright (C) 2010, 2011, 2012  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 /* Replace auto-increment addressing modes with explicit operations to access
  33    the same addresses without modifying the corresponding registers.  */
  34
  35 #ifdef AUTO_INC_DEC
  36 static rtx
  37 cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode ATTRIBUTE_UNUSED)
  38 {
  39   rtx x = src;
  40   const RTX_CODE code = GET_CODE (x);
  41   int i;
  42   const char *fmt;
  43
  44   switch (code)
  45     {
  46     case REG:
  47     case CONST_INT:
  48     case CONST_DOUBLE:
  49     case CONST_FIXED:
  50     case CONST_VECTOR:
  51     case SYMBOL_REF:
  52     case CODE_LABEL:
  53     case PC:
  54     case CC0:
  55     case SCRATCH:
  56       /* SCRATCH must be shared because they represent distinct values.  */
  57       return x;
  58     case CLOBBER:
  59       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
  60         return x;
  61       break;
  62
  63     case CONST:
  64       if (shared_const_p (x))
  65         return x;
  66       break;
  67
  68     case MEM:
  69       mem_mode = GET_MODE (x);
  70       break;
  71
  72     case PRE_INC:
  73     case PRE_DEC:
  74       gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
  75       return gen_rtx_PLUS (GET_MODE (x),
  76                            cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
  77                            GEN_INT (code == PRE_INC
  78                                     ? GET_MODE_SIZE (mem_mode)
  79                                     : -GET_MODE_SIZE (mem_mode)));
  80
  81     case POST_INC:
  82     case POST_DEC:
  83     case PRE_MODIFY:
  84     case POST_MODIFY:
  85       return cleanup_auto_inc_dec (code == PRE_MODIFY
  86                                    ? XEXP (x, 1) : XEXP (x, 0),
  87                                    mem_mode);
  88
  89     default:
  90       break;
  91     }
  92
  93   /* Copy the various flags, fields, and other information.  We assume
  94      that all fields need copying, and then clear the fields that should
  95      not be copied.  That is the sensible default behavior, and forces
  96      us to explicitly document why we are *not* copying a flag.  */
  97   x = shallow_copy_rtx (x);
  98
  99   /* We do not copy the USED flag, which is used as a mark bit during
 100      walks over the RTL.  */
 101   RTX_FLAG (x, used) = 0;
 102
 103   /* We do not copy FRAME_RELATED for INSNs.  */
 104   if (INSN_P (x))
 105     RTX_FLAG (x, frame_related) = 0;
 106
 107   fmt = GET_RTX_FORMAT (code);
 108   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 109     if (fmt[i] == 'e')
 110       XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
 111     else if (fmt[i] == 'E' || fmt[i] == 'V')
 112       {
 113         int j;
 114         XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
 115         for (j = 0; j < XVECLEN (x, i); j++)
 116           XVECEXP (x, i, j)
 117             = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
 118       }
 119
 120   return x;
 121 }
 122 #endif
 123
 124 /* Auxiliary data structure for propagate_for_debug_stmt.  */
 125
 126 struct rtx_subst_pair
 127 {
 128   rtx to;
 129   bool adjusted;
 130 };
 131
 132 /* DATA points to an rtx_subst_pair.  Return the value that should be
 133    substituted.  */
 134
 135 static rtx
 136 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
 137 {
 138   struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
 139
 140   if (!rtx_equal_p (from, old_rtx))
 141     return NULL_RTX;
 142   if (!pair->adjusted)
 143     {
 144       pair->adjusted = true;
 145 #ifdef AUTO_INC_DEC
 146       pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
 147 #else
 148       pair->to = copy_rtx (pair->to);
 149 #endif
 150       pair->to = make_compound_operation (pair->to, SET);
 151       return pair->to;
 152     }
 153   return copy_rtx (pair->to);
 154 }
 155
 156 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
 157    and LAST, not including INSN, but including LAST.  Also stop at the end
 158    of THIS_BASIC_BLOCK.  */
 159
 160 void
 161 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src,
 162                      basic_block this_basic_block)
 163 {
 164   rtx next, loc, end = NEXT_INSN (BB_END (this_basic_block));
 165
 166   struct rtx_subst_pair p;
 167   p.to = src;
 168   p.adjusted = false;
 169
 170   next = NEXT_INSN (insn);
 171   last = NEXT_INSN (last);
 172   while (next != last && next != end)
 173     {
 174       insn = next;
 175       next = NEXT_INSN (insn);
 176       if (DEBUG_INSN_P (insn))
 177         {
 178           loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
 179                                          dest, propagate_for_debug_subst, &p);
 180           if (loc == INSN_VAR_LOCATION_LOC (insn))
 181             continue;
 182           INSN_VAR_LOCATION_LOC (insn) = loc;
 183           df_insn_rescan (insn);
 184         }
 185     }
 186 }
 187
 188 /* Initialize DEBUG to an empty list, and clear USED, if given.  */
 189 void
 190 dead_debug_init (struct dead_debug *debug, bitmap used)
 191 {
 192   debug->head = NULL;
 193   debug->used = used;
 194   debug->to_rescan = NULL;
 195   if (used)
 196     bitmap_clear (used);
 197 }
 198
 199 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
 200    each reset insn.  DEBUG is not otherwise modified.  If HEAD is
 201    DEBUG->head, DEBUG->head will be set to NULL at the end.
 202    Otherwise, entries from DEBUG->head that pertain to reset insns
 203    will be removed, and only then rescanned.  */
 204
 205 static void
 206 dead_debug_reset_uses (struct dead_debug *debug, struct dead_debug_use *head)
 207 {
 208   bool got_head = (debug->head == head);
 209   bitmap rescan;
 210   struct dead_debug_use **tailp = &debug->head;
 211   struct dead_debug_use *cur;
 212   bitmap_iterator bi;
 213   unsigned int uid;
 214
 215   if (got_head)
 216     rescan = NULL;
 217   else
 218     rescan = BITMAP_ALLOC (NULL);
 219
 220   while (head)
 221     {
 222       struct dead_debug_use *next = head->next;
 223       rtx insn;
 224
 225       insn = DF_REF_INSN (head->use);
 226       if (!next || DF_REF_INSN (next->use) != insn)
 227         {
 228           INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
 229           if (got_head)
 230             df_insn_rescan_debug_internal (insn);
 231           else
 232             bitmap_set_bit (rescan, INSN_UID (insn));
 233           if (debug->to_rescan)
 234             bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
 235         }
 236       XDELETE (head);
 237       head = next;
 238     }
 239
 240   if (got_head)
 241     {
 242       debug->head = NULL;
 243       return;
 244     }
 245
 246   while ((cur = *tailp))
 247     if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
 248       {
 249         *tailp = cur->next;
 250         XDELETE (cur);
 251       }
 252     else
 253       tailp = &cur->next;
 254
 255   EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
 256     {
 257       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 258       if (insn_info)
 259         df_insn_rescan_debug_internal (insn_info->insn);
 260     }
 261
 262   BITMAP_FREE (rescan);
 263 }
 264
 265 /* Reset all debug insns with pending uses.  Release the bitmap in it,
 266    unless it is USED.  USED must be the same bitmap passed to
 267    dead_debug_init.  */
 268 void
 269 dead_debug_finish (struct dead_debug *debug, bitmap used)
 270 {
 271   if (debug->used != used)
 272     BITMAP_FREE (debug->used);
 273
 274   dead_debug_reset_uses (debug, debug->head);
 275
 276   if (debug->to_rescan)
 277     {
 278       bitmap_iterator bi;
 279       unsigned int uid;
 280
 281       EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
 282         {
 283           struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 284           if (insn_info)
 285             df_insn_rescan (insn_info->insn);
 286         }
 287       BITMAP_FREE (debug->to_rescan);
 288     }
 289 }
 290
 291 /* Add USE to DEBUG.  It must be a dead reference to UREGNO in a debug
 292    insn.  Create a bitmap for DEBUG as needed.  */
 293 void
 294 dead_debug_add (struct dead_debug *debug, df_ref use, unsigned int uregno)
 295 {
 296   struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
 297
 298   newddu->use = use;
 299   newddu->next = debug->head;
 300   debug->head = newddu;
 301
 302   if (!debug->used)
 303     debug->used = BITMAP_ALLOC (NULL);
 304
 305   /* ??? If we dealt with split multi-registers below, we should set
 306      all registers for the used mode in case of hardware
 307      registers.  */
 308   bitmap_set_bit (debug->used, uregno);
 309 }
 310
 311 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
 312    before or after INSN (depending on WHERE), that binds a debug temp
 313    to the widest-mode use of UREGNO, if WHERE is *_WITH_REG, or the
 314    value stored in UREGNO by INSN otherwise, and replace all uses of
 315    UREGNO in DEBUG with uses of the debug temp.  INSN must be where
 316    UREGNO dies, if WHERE is *_BEFORE_*, or where it is set otherwise.
 317    Return the number of debug insns emitted.  */
 318 int
 319 dead_debug_insert_temp (struct dead_debug *debug, unsigned int uregno,
 320                         rtx insn, enum debug_temp_where where)
 321 {
 322   struct dead_debug_use **tailp = &debug->head;
 323   struct dead_debug_use *cur;
 324   struct dead_debug_use *uses = NULL;
 325   struct dead_debug_use **usesp = &uses;
 326   rtx reg = NULL;
 327   rtx breg;
 328   rtx dval;
 329   rtx bind;
 330
 331   if (!debug->used || !bitmap_clear_bit (debug->used, uregno))
 332     return 0;
 333
 334   /* Move all uses of uregno from debug->head to uses, setting mode to
 335      the widest referenced mode.  */
 336   while ((cur = *tailp))
 337     {
 338       if (DF_REF_REGNO (cur->use) == uregno)
 339         {
 340           *usesp = cur;
 341           usesp = &cur->next;
 342           *tailp = cur->next;
 343           cur->next = NULL;
 344           if (!reg
 345               || (GET_MODE_BITSIZE (GET_MODE (reg))
 346                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 347             reg = *DF_REF_REAL_LOC (cur->use);
 348         }
 349       else
 350         tailp = &(*tailp)->next;
 351     }
 352
 353   /* We may have dangling bits in debug->used for registers that were part
 354      of a multi-register use, one component of which has been reset.  */
 355   if (reg == NULL)
 356     {
 357       gcc_checking_assert (!uses);
 358       return 0;
 359     }
 360
 361   gcc_checking_assert (uses);
 362
 363   breg = reg;
 364   /* Recover the expression INSN stores in REG.  */
 365   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 366     {
 367       rtx set = single_set (insn);
 368       rtx dest, src;
 369
 370       if (set)
 371         {
 372           dest = SET_DEST (set);
 373           src = SET_SRC (set);
 374           /* Lose if the REG-setting insn is a CALL.  */
 375           if (GET_CODE (src) == CALL)
 376             {
 377               while (uses)
 378                 {
 379                   cur = uses->next;
 380                   XDELETE (uses);
 381                   uses = cur;
 382                 }
 383               return 0;
 384             }
 385         }
 386
 387       /* ??? Should we try to extract it from a PARALLEL?  */
 388       if (!set)
 389         breg = NULL;
 390       /* Cool, it's the same REG, we can use SRC.  */
 391       else if (dest == reg)
 392         breg = copy_rtx (src);
 393       else if (REG_P (dest))
 394         {
 395           /* Hmm...  Something's fishy, we should be setting REG here.  */
 396           if (REGNO (dest) != REGNO (reg))
 397             breg = NULL;
 398           /* If we're not overwriting all the hardware registers that
 399              setting REG in its mode would, we won't know what to bind
 400              the debug temp to.  ??? We could bind the debug_expr to a
 401              CONCAT or PARALLEL with the split multi-registers, and
 402              replace them as we found the corresponding sets.  */
 403           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 404                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 405                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 406             breg = NULL;
 407           /* Ok, it's the same (hardware) REG, but with a different
 408              mode, so SUBREG it.  */
 409           else
 410             breg = lowpart_subreg (GET_MODE (reg), copy_rtx (src),
 411                                    GET_MODE (dest));
 412         }
 413       else if (GET_CODE (dest) == SUBREG)
 414         {
 415           /* We should be setting REG here.  Lose.  */
 416           if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
 417             breg = NULL;
 418           /* Lose if we're setting something other than the lowpart of
 419              REG.  */
 420           else if (!subreg_lowpart_p (dest))
 421             breg = NULL;
 422           /* If we're not overwriting all the hardware registers that
 423              setting REG in its mode would, we won't know what to bind
 424              the debug temp to.  */
 425           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 426                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 427                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 428             breg = NULL;
 429           /* Yay, we can use SRC, just adjust its mode.  */
 430           else
 431             breg = lowpart_subreg (GET_MODE (reg), copy_rtx (src),
 432                                    GET_MODE (dest));
 433         }
 434       /* Oh well, we're out of luck.  */
 435       else
 436         breg = NULL;
 437
 438       /* We couldn't figure out the value stored in REG, so reset all
 439          of its pending debug uses.  */
 440       if (!breg)
 441         {
 442           dead_debug_reset_uses (debug, uses);
 443           return 0;
 444         }
 445     }
 446
 447   /* If there's a single (debug) use of an otherwise unused REG, and
 448      the debug use is not part of a larger expression, then it
 449      probably doesn't make sense to introduce a new debug temp.  */
 450   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 451     {
 452       rtx next = DF_REF_INSN (uses->use);
 453
 454       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 455         {
 456           XDELETE (uses);
 457           return 0;
 458         }
 459     }
 460
 461   /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 462   dval = make_debug_expr_from_rtl (reg);
 463
 464   /* Emit a debug bind insn before the insn in which reg dies.  */
 465   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 466                                DEBUG_EXPR_TREE_DECL (dval), breg,
 467                                VAR_INIT_STATUS_INITIALIZED);
 468
 469   if (where == DEBUG_TEMP_AFTER_WITH_REG)
 470     bind = emit_debug_insn_after (bind, insn);
 471   else
 472     bind = emit_debug_insn_before (bind, insn);
 473   df_insn_rescan (bind);
 474
 475   /* Adjust all uses.  */
 476   while ((cur = uses))
 477     {
 478       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 479         *DF_REF_REAL_LOC (cur->use) = dval;
 480       else
 481         *DF_REF_REAL_LOC (cur->use)
 482           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 483       /* ??? Should we simplify subreg of subreg?  */
 484       if (debug->to_rescan == NULL)
 485         debug->to_rescan = BITMAP_ALLOC (NULL);
 486       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 487       uses = cur->next;
 488       XDELETE (cur);
 489     }
 490
 491   return 1;
 492 }