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           *usesp = cur;
 337           usesp = &cur->next;
 338           *tailp = cur->next;
 339           cur->next = NULL;
 340           if (!reg
 341               || (GET_MODE_BITSIZE (GET_MODE (reg))
 342                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 343             reg = *DF_REF_REAL_LOC (cur->use);
 344         }
 345       else
 346         tailp = &(*tailp)->next;
 347     }
 348
 349   /* We may have dangling bits in debug->used for registers that were part
 350      of a multi-register use, one component of which has been reset.  */
 351   if (reg == NULL)
 352     {
 353       gcc_checking_assert (!uses);
 354       return 0;
 355     }
 356
 357   gcc_checking_assert (uses);
 358
 359   breg = reg;
 360   /* Recover the expression INSN stores in REG.  */
 361   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 362     {
 363       rtx set = single_set (insn);
 364       rtx dest, src;
 365
 366       if (set)
 367         {
 368           dest = SET_DEST (set);
 369           src = SET_SRC (set);
 370           /* Lose if the REG-setting insn is a CALL.  */
 371           if (GET_CODE (src) == CALL)
 372             {
 373               while (uses)
 374                 {
 375                   cur = uses->next;
 376                   XDELETE (uses);
 377                   uses = cur;
 378                 }
 379               return 0;
 380             }
 381         }
 382
 383       /* ??? Should we try to extract it from a PARALLEL?  */
 384       if (!set)
 385         breg = NULL;
 386       /* Cool, it's the same REG, we can use SRC.  */
 387       else if (dest == reg)
 388         breg = cleanup_auto_inc_dec (src, VOIDmode);
 389       else if (REG_P (dest))
 390         {
 391           /* Hmm...  Something's fishy, we should be setting REG here.  */
 392           if (REGNO (dest) != REGNO (reg))
 393             breg = NULL;
 394           /* If we're not overwriting all the hardware registers that
 395              setting REG in its mode would, we won't know what to bind
 396              the debug temp to.  ??? We could bind the debug_expr to a
 397              CONCAT or PARALLEL with the split multi-registers, and
 398              replace them as we found the corresponding sets.  */
 399           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 400                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 401                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 402             breg = NULL;
 403           /* Ok, it's the same (hardware) REG, but with a different
 404              mode, so SUBREG it.  */
 405           else
 406             breg = lowpart_subreg (GET_MODE (reg),
 407                                    cleanup_auto_inc_dec (src, VOIDmode),
 408                                    GET_MODE (dest));
 409         }
 410       else if (GET_CODE (dest) == SUBREG)
 411         {
 412           /* We should be setting REG here.  Lose.  */
 413           if (REGNO (SUBREG_REG (dest)) != REGNO (reg))
 414             breg = NULL;
 415           /* Lose if we're setting something other than the lowpart of
 416              REG.  */
 417           else if (!subreg_lowpart_p (dest))
 418             breg = NULL;
 419           /* If we're not overwriting all the hardware registers that
 420              setting REG in its mode would, we won't know what to bind
 421              the debug temp to.  */
 422           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 423                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 424                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 425             breg = NULL;
 426           /* Yay, we can use SRC, just adjust its mode.  */
 427           else
 428             breg = lowpart_subreg (GET_MODE (reg),
 429                                    cleanup_auto_inc_dec (src, VOIDmode),
 430                                    GET_MODE (dest));
 431         }
 432       /* Oh well, we're out of luck.  */
 433       else
 434         breg = NULL;
 435
 436       /* We couldn't figure out the value stored in REG, so reset all
 437          of its pending debug uses.  */
 438       if (!breg)
 439         {
 440           dead_debug_reset_uses (debug, uses);
 441           return 0;
 442         }
 443     }
 444
 445   /* If there's a single (debug) use of an otherwise unused REG, and
 446      the debug use is not part of a larger expression, then it
 447      probably doesn't make sense to introduce a new debug temp.  */
 448   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 449     {
 450       rtx next = DF_REF_INSN (uses->use);
 451
 452       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 453         {
 454           XDELETE (uses);
 455           return 0;
 456         }
 457     }
 458
 459   /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 460   dval = make_debug_expr_from_rtl (reg);
 461
 462   /* Emit a debug bind insn before the insn in which reg dies.  */
 463   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 464                                DEBUG_EXPR_TREE_DECL (dval), breg,
 465                                VAR_INIT_STATUS_INITIALIZED);
 466
 467   if (where == DEBUG_TEMP_AFTER_WITH_REG)
 468     bind = emit_debug_insn_after (bind, insn);
 469   else
 470     bind = emit_debug_insn_before (bind, insn);
 471   df_insn_rescan (bind);
 472
 473   /* Adjust all uses.  */
 474   while ((cur = uses))
 475     {
 476       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 477         *DF_REF_REAL_LOC (cur->use) = dval;
 478       else
 479         *DF_REF_REAL_LOC (cur->use)
 480           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 481       /* ??? Should we simplify subreg of subreg?  */
 482       if (debug->to_rescan == NULL)
 483         debug->to_rescan = BITMAP_ALLOC (NULL);
 484       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 485       uses = cur->next;
 486       XDELETE (cur);
 487     }
 488
 489   return 1;
 490 }