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_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 #else /* !AUTO_INC_DEC */
 121   x = copy_rtx (x);
 122 #endif /* !AUTO_INC_DEC */
 123
 124   return x;
 125 }
 126
 127 /* Auxiliary data structure for propagate_for_debug_stmt.  */
 128
 129 struct rtx_subst_pair
 130 {
 131   rtx to;
 132   bool adjusted;
 133 };
 134
 135 /* DATA points to an rtx_subst_pair.  Return the value that should be
 136    substituted.  */
 137
 138 static rtx
 139 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
 140 {
 141   struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
 142
 143   if (!rtx_equal_p (from, old_rtx))
 144     return NULL_RTX;
 145   if (!pair->adjusted)
 146     {
 147       pair->adjusted = true;
 148       pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
 149       pair->to = make_compound_operation (pair->to, SET);
 150       return pair->to;
 151     }
 152   return copy_rtx (pair->to);
 153 }
 154
 155 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
 156    and LAST, not including INSN, but including LAST.  Also stop at the end
 157    of THIS_BASIC_BLOCK.  */
 158
 159 void
 160 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src,
 161                      basic_block this_basic_block)
 162 {
 163   rtx next, loc, end = NEXT_INSN (BB_END (this_basic_block));
 164
 165   struct rtx_subst_pair p;
 166   p.to = src;
 167   p.adjusted = false;
 168
 169   next = NEXT_INSN (insn);
 170   last = NEXT_INSN (last);
 171   while (next != last && next != end)
 172     {
 173       insn = next;
 174       next = NEXT_INSN (insn);
 175       if (DEBUG_INSN_P (insn))
 176         {
 177           loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
 178                                          dest, propagate_for_debug_subst, &p);
 179           if (loc == INSN_VAR_LOCATION_LOC (insn))
 180             continue;
 181           INSN_VAR_LOCATION_LOC (insn) = loc;
 182           df_insn_rescan (insn);
 183         }
 184     }
 185 }
 186
 187 /* Initialize DEBUG to an empty list, and clear USED, if given.  */
 188 void
 189 dead_debug_init (struct dead_debug *debug, bitmap used)
 190 {
 191   debug->head = NULL;
 192   debug->used = used;
 193   debug->to_rescan = NULL;
 194   if (used)
 195     bitmap_clear (used);
 196 }
 197
 198 /* Reset all debug uses in HEAD, and clear DEBUG->to_rescan bits of
 199    each reset insn.  DEBUG is not otherwise modified.  If HEAD is
 200    DEBUG->head, DEBUG->head will be set to NULL at the end.
 201    Otherwise, entries from DEBUG->head that pertain to reset insns
 202    will be removed, and only then rescanned.  */
 203
 204 static void
 205 dead_debug_reset_uses (struct dead_debug *debug, struct dead_debug_use *head)
 206 {
 207   bool got_head = (debug->head == head);
 208   bitmap rescan;
 209   struct dead_debug_use **tailp = &debug->head;
 210   struct dead_debug_use *cur;
 211   bitmap_iterator bi;
 212   unsigned int uid;
 213
 214   if (got_head)
 215     rescan = NULL;
 216   else
 217     rescan = BITMAP_ALLOC (NULL);
 218
 219   while (head)
 220     {
 221       struct dead_debug_use *next = head->next;
 222       rtx insn;
 223
 224       insn = DF_REF_INSN (head->use);
 225       if (!next || DF_REF_INSN (next->use) != insn)
 226         {
 227           INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
 228           if (got_head)
 229             df_insn_rescan_debug_internal (insn);
 230           else
 231             bitmap_set_bit (rescan, INSN_UID (insn));
 232           if (debug->to_rescan)
 233             bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
 234         }
 235       XDELETE (head);
 236       head = next;
 237     }
 238
 239   if (got_head)
 240     {
 241       debug->head = NULL;
 242       return;
 243     }
 244
 245   while ((cur = *tailp))
 246     if (bitmap_bit_p (rescan, INSN_UID (DF_REF_INSN (cur->use))))
 247       {
 248         *tailp = cur->next;
 249         XDELETE (cur);
 250       }
 251     else
 252       tailp = &cur->next;
 253
 254   EXECUTE_IF_SET_IN_BITMAP (rescan, 0, uid, bi)
 255     {
 256       struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 257       if (insn_info)
 258         df_insn_rescan_debug_internal (insn_info->insn);
 259     }
 260
 261   BITMAP_FREE (rescan);
 262 }
 263
 264 /* Reset all debug insns with pending uses.  Release the bitmap in it,
 265    unless it is USED.  USED must be the same bitmap passed to
 266    dead_debug_init.  */
 267 void
 268 dead_debug_finish (struct dead_debug *debug, bitmap used)
 269 {
 270   if (debug->used != used)
 271     BITMAP_FREE (debug->used);
 272
 273   dead_debug_reset_uses (debug, debug->head);
 274
 275   if (debug->to_rescan)
 276     {
 277       bitmap_iterator bi;
 278       unsigned int uid;
 279
 280       EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
 281         {
 282           struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
 283           if (insn_info)
 284             df_insn_rescan (insn_info->insn);
 285         }
 286       BITMAP_FREE (debug->to_rescan);
 287     }
 288 }
 289
 290 /* Add USE to DEBUG.  It must be a dead reference to UREGNO in a debug
 291    insn.  Create a bitmap for DEBUG as needed.  */
 292 void
 293 dead_debug_add (struct dead_debug *debug, df_ref use, unsigned int uregno)
 294 {
 295   struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
 296
 297   newddu->use = use;
 298   newddu->next = debug->head;
 299   debug->head = newddu;
 300
 301   if (!debug->used)
 302     debug->used = BITMAP_ALLOC (NULL);
 303
 304   /* ??? If we dealt with split multi-registers below, we should set
 305      all registers for the used mode in case of hardware
 306      registers.  */
 307   bitmap_set_bit (debug->used, uregno);
 308 }
 309
 310 /* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
 311    before or after INSN (depending on WHERE), that binds a debug temp
 312    to the widest-mode use of UREGNO, if WHERE is *_WITH_REG, or the
 313    value stored in UREGNO by INSN otherwise, and replace all uses of
 314    UREGNO in DEBUG with uses of the debug temp.  INSN must be where
 315    UREGNO dies, if WHERE is *_BEFORE_*, or where it is set otherwise.
 316    Return the number of debug insns emitted.  */
 317 int
 318 dead_debug_insert_temp (struct dead_debug *debug, unsigned int uregno,
 319                         rtx insn, enum debug_temp_where where)
 320 {
 321   struct dead_debug_use **tailp = &debug->head;
 322   struct dead_debug_use *cur;
 323   struct dead_debug_use *uses = NULL;
 324   struct dead_debug_use **usesp = &uses;
 325   rtx reg = NULL;
 326   rtx breg;
 327   rtx dval;
 328   rtx bind;
 329
 330   if (!debug->used || !bitmap_clear_bit (debug->used, uregno))
 331     return 0;
 332
 333   /* Move all uses of uregno from debug->head to uses, setting mode to
 334      the widest referenced mode.  */
 335   while ((cur = *tailp))
 336     {
 337       if (DF_REF_REGNO (cur->use) == uregno)
 338         {
 339           *usesp = cur;
 340           usesp = &cur->next;
 341           *tailp = cur->next;
 342           cur->next = NULL;
 343           if (!reg
 344               || (GET_MODE_BITSIZE (GET_MODE (reg))
 345                   < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
 346             reg = *DF_REF_REAL_LOC (cur->use);
 347         }
 348       else
 349         tailp = &(*tailp)->next;
 350     }
 351
 352   /* We may have dangling bits in debug->used for registers that were part
 353      of a multi-register use, one component of which has been reset.  */
 354   if (reg == NULL)
 355     {
 356       gcc_checking_assert (!uses);
 357       return 0;
 358     }
 359
 360   gcc_checking_assert (uses);
 361
 362   breg = reg;
 363   /* Recover the expression INSN stores in REG.  */
 364   if (where == DEBUG_TEMP_BEFORE_WITH_VALUE)
 365     {
 366       rtx set = single_set (insn);
 367       rtx dest, src;
 368
 369       if (set)
 370         {
 371           dest = SET_DEST (set);
 372           src = SET_SRC (set);
 373           /* Lose if the REG-setting insn is a CALL.  */
 374           if (GET_CODE (src) == CALL)
 375             {
 376               while (uses)
 377                 {
 378                   cur = uses->next;
 379                   XDELETE (uses);
 380                   uses = cur;
 381                 }
 382               return 0;
 383             }
 384         }
 385
 386       /* ??? Should we try to extract it from a PARALLEL?  */
 387       if (!set)
 388         breg = NULL;
 389       /* Cool, it's the same REG, we can use SRC.  */
 390       else if (dest == reg)
 391         breg = cleanup_auto_inc_dec (src, VOIDmode);
 392       else if (REG_P (dest))
 393         {
 394           /* Hmm...  Something's fishy, we should be setting REG here.  */
 395           if (REGNO (dest) != REGNO (reg))
 396             breg = NULL;
 397           /* If we're not overwriting all the hardware registers that
 398              setting REG in its mode would, we won't know what to bind
 399              the debug temp to.  ??? We could bind the debug_expr to a
 400              CONCAT or PARALLEL with the split multi-registers, and
 401              replace them as we found the corresponding sets.  */
 402           else if (REGNO (reg) < FIRST_PSEUDO_REGISTER
 403                    && (hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]
 404                        != hard_regno_nregs[REGNO (reg)][GET_MODE (dest)]))
 405             breg = NULL;
 406           /* Ok, it's the same (hardware) REG, but with a different
 407              mode, so SUBREG it.  */
 408           else
 409             breg = lowpart_subreg (GET_MODE (reg),
 410                                    cleanup_auto_inc_dec (src, VOIDmode),
 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),
 432                                    cleanup_auto_inc_dec (src, VOIDmode),
 433                                    GET_MODE (dest));
 434         }
 435       /* Oh well, we're out of luck.  */
 436       else
 437         breg = NULL;
 438
 439       /* We couldn't figure out the value stored in REG, so reset all
 440          of its pending debug uses.  */
 441       if (!breg)
 442         {
 443           dead_debug_reset_uses (debug, uses);
 444           return 0;
 445         }
 446     }
 447
 448   /* If there's a single (debug) use of an otherwise unused REG, and
 449      the debug use is not part of a larger expression, then it
 450      probably doesn't make sense to introduce a new debug temp.  */
 451   if (where == DEBUG_TEMP_AFTER_WITH_REG && !uses->next)
 452     {
 453       rtx next = DF_REF_INSN (uses->use);
 454
 455       if (DEBUG_INSN_P (next) && reg == INSN_VAR_LOCATION_LOC (next))
 456         {
 457           XDELETE (uses);
 458           return 0;
 459         }
 460     }
 461
 462   /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
 463   dval = make_debug_expr_from_rtl (reg);
 464
 465   /* Emit a debug bind insn before the insn in which reg dies.  */
 466   bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
 467                                DEBUG_EXPR_TREE_DECL (dval), breg,
 468                                VAR_INIT_STATUS_INITIALIZED);
 469
 470   if (where == DEBUG_TEMP_AFTER_WITH_REG)
 471     bind = emit_debug_insn_after (bind, insn);
 472   else
 473     bind = emit_debug_insn_before (bind, insn);
 474   df_insn_rescan (bind);
 475
 476   /* Adjust all uses.  */
 477   while ((cur = uses))
 478     {
 479       if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
 480         *DF_REF_REAL_LOC (cur->use) = dval;
 481       else
 482         *DF_REF_REAL_LOC (cur->use)
 483           = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
 484       /* ??? Should we simplify subreg of subreg?  */
 485       if (debug->to_rescan == NULL)
 486         debug->to_rescan = BITMAP_ALLOC (NULL);
 487       bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
 488       uses = cur->next;
 489       XDELETE (cur);
 490     }
 491
 492   return 1;
 493 }