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