gcc/df-byte-scan.c

   1 /* Scanning of rtl byte level scanning for dataflow analysis.
   2    Copyright (C) 2008  Free Software Foundation, Inc.
   3    Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "rtl.h"
  26 #include "tm_p.h"
  27 #include "df.h"
  28 #include "output.h"
  29 #include "dbgcnt.h"
  30
  31 /* The following suite of functions provides bytewise modeling of REFs
  32    which are struct df_ref.  START_BYTE and LAST_BYTE are returned.
  33    These can be used as indexes into bitmaps.  The indexes are
  34    normalized so that 0 is the lowest numbered byte, of the inner
  35    register according to the natural ordering of the machine.
  36
  37    This code is designed to be used in backwards scans (which is, of
  38    course, the way all dataflow scanning should really be done).  It
  39    would require a lot of reworking of the api to make it work in a
  40    forwards scanning world.  */
  41
  42
  43 /* Helper for df_compute_accessed_bytes.  Ref is some sort of extract.
  44    Return true if this effects the entire reg in REF.  Return false if
  45    otherwise and set START_BYTE and LAST_BYTE.  See the description of
  46    df_compute_accessed_bytes for a description of MM.  */
  47
  48 static bool
  49 df_compute_accessed_bytes_extract (df_ref ref,
  50                                    enum df_mm mm ,
  51                                    unsigned int *start_byte,
  52                                    unsigned int *last_byte)
  53 {
  54   int start;
  55   int last;
  56   rtx reg = DF_REF_REG (ref);
  57   enum machine_mode m1;
  58   int m1_size;
  59   enum machine_mode m2;
  60   int m2_size;
  61
  62   /* (*_extract:M1 (reg:M2 X) WIDTH POS)
  63      (*_extract:M1 (subreg:M1 (reg:M2 X N) WIDTH POS)
  64
  65      This is a bitfield extraction.  The assignment clobbers/extracts
  66      exactly the bits named by WIDTH and POS and does not affect the
  67      other bits in register X.  It is also technically possible that
  68      the bits asked for are longer than units per word.  */
  69
  70   int offset = DF_REF_EXTRACT_OFFSET (ref);
  71   int width = DF_REF_EXTRACT_WIDTH (ref);
  72
  73   if (width == -1 || offset == -1)
  74     return true;
  75
  76   m1 = DF_REF_EXTRACT_MODE (ref);
  77   m1_size = GET_MODE_SIZE (m1);
  78
  79   gcc_assert (m1_size <= UNITS_PER_WORD);
  80
  81   /* There is nothing to do if this is a pure big or small endian
  82      machine, but if the machine is a pastiche, we have to convert the
  83      bit offsets into byte offsets.  This is only possible because we
  84      do not care about individual bits because this conversion may
  85      make the bits non-contiguous.  */
  86   if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
  87     offset = GET_MODE_BITSIZE (m1_size) - (offset + width);
  88
  89   /* The offset is now in the same order as the subreg_byte.  */
  90   if (GET_CODE (reg) == SUBREG)
  91     {
  92       m2 = GET_MODE (SUBREG_REG (reg));
  93       m2_size = GET_MODE_SIZE (m2);
  94       if (m1_size > m2_size)
  95         /* If it is paradoxical, subreg_byte will be zero.  */
  96         offset -= subreg_lowpart_offset (m2, m1) * BITS_PER_UNIT;
  97       else
  98         offset += SUBREG_BYTE (reg) * BITS_PER_UNIT;
  99     }
 100   else
 101     {
 102       m2 = GET_MODE (reg);
 103       m2_size = GET_MODE_SIZE (m2);
 104     }
 105
 106   if (mm == DF_MM_MUST)
 107     {
 108       /* For defs (generally), count the byte only if the whole byte
 109          is touched.  */
 110       start = (offset + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 111       last = (width + offset) / BITS_PER_UNIT;
 112
 113       /* In the case where there is nothing, start may be one larger
 114          than last, we canonize this to return zeros.  This keeps
 115          computations of length from being negative.  */
 116       if (start >= last)
 117         {
 118           start = 0;
 119           last = 0;
 120         }
 121     }
 122   else
 123     {
 124       /* For uses (generally), count the byte if any part of the byte
 125          is touched.  */
 126       start = offset / BITS_PER_UNIT;
 127       last = (width + offset + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 128     }
 129
 130   /* Paradoxical truncation.  */
 131   if (start < 0)
 132     start = 0;
 133   if (last > m2_size)
 134     last = m2_size;
 135
 136   if (dump_file)
 137     fprintf (dump_file, "    cpb extract regno=%d start=%d last=%d\n",
 138              DF_REF_REGNO (ref), start, last);
 139
 140   *start_byte = start;
 141   *last_byte = last;
 142   return false;
 143 }
 144
 145
 146 /* Helper for df_compute_accessed_bytes.  Ref is a strict_low_part.
 147    Return true if this effects the entire reg in REF. Return false if
 148    otherwise and set START_BYTE and LAST_BYTE.  */
 149
 150 static bool
 151 df_compute_accessed_bytes_strict_low_part (df_ref ref,
 152                                            unsigned int *start_byte,
 153                                            unsigned int *last_byte)
 154 {
 155   int start;
 156   int last;
 157   rtx reg = DF_REF_REG (ref);
 158   enum machine_mode m1;
 159   int m1_size;
 160   enum machine_mode m2;
 161   int m2_size;
 162   int offset;
 163
 164   /* In order to accommodate multiword subregs of a hardreg, df_scan
 165      eats the subreg and it can only be found from the loc.  */
 166   if (REG_P (reg))
 167     reg = *(DF_REF_LOC (ref));
 168
 169   m1 = GET_MODE (reg);
 170   m1_size = GET_MODE_SIZE (m1);
 171   m2 = GET_MODE (SUBREG_REG (reg));
 172   m2_size = GET_MODE_SIZE (m2);
 173   offset = SUBREG_BYTE (reg);
 174
 175   /* It does not seem to be meaningful to apply a strict_low_part of a
 176      paradoxical register.  */
 177   gcc_assert (m1_size <= m2_size);
 178
 179   /* (set (strict_low_part (subreg:M1 (reg:M2 X) N)) ...)
 180
 181   This is a bitfield insertion.  The assignment clobbers exactly the
 182   bits named by the subreg--the M1 bits at position N.  It is also
 183   technically possible that the bits asked for are longer than units
 184   per word.  */
 185
 186   start = offset;
 187   last = offset + m1_size;
 188
 189   if (dump_file)
 190     fprintf (dump_file, "    cpb strict low part regno=%d start=%d last=%d\n",
 191              DF_REF_REGNO (ref), start, last);
 192
 193   *start_byte = start;
 194   *last_byte = last;
 195   return false;
 196 }
 197
 198 /* Helper for df_compute_accessed_bytes.  Ref is a naked subreg.
 199    Return true if this effects the entire reg in REF. Return false if
 200    otherwise and set START_BYTE and LAST_BYTE.  */
 201
 202 static bool
 203 df_compute_accessed_bytes_subreg (df_ref ref, unsigned int *start_byte,
 204                                   unsigned int *last_byte)
 205
 206 {
 207   /* (subreg:M1 (reg:M2 X) N) */
 208   int start;
 209   int last;
 210   rtx reg = DF_REF_REG (ref);
 211
 212   enum machine_mode m1;
 213   int m1_size;
 214   enum machine_mode m2;
 215   int m2_size;
 216
 217   /* In order to accommodate multiword subregs of a hardreg, df_scan
 218      eats the subreg and it can only be found from the loc.  */
 219   if (REG_P (reg))
 220     reg = *(DF_REF_LOC (ref));
 221
 222   m1 = GET_MODE (reg);
 223   m1_size = GET_MODE_SIZE (m1);
 224   m2 = GET_MODE (SUBREG_REG (reg));
 225   m2_size = GET_MODE_SIZE (m2);
 226
 227   /* A simple paradoxical subreg just accesses the entire inner reg.  */
 228   if (m1_size >= m2_size)
 229     return true;
 230
 231   /* Defs and uses are different in the amount of the reg that touch.  */
 232   if (DF_REF_REG_DEF_P (ref))
 233     {
 234       /* This is an lvalue.  */
 235
 236       if (m2_size > UNITS_PER_WORD)
 237         {
 238           /* The assignment clobbers UNITS_PER_WORD segments of X.
 239              Look at the bytes named by the subreg, and expand it to
 240              cover a UNITS_PER_WORD part of register X.  That part of
 241              register X is clobbered, the rest is not.
 242
 243              E.g., (subreg:SI (reg:DI X) 0), where UNITS_PER_WORD is the
 244              size of SImode, clobbers the first SImode part of X, and does
 245              not affect the second SImode part.
 246
 247              E.g., (subreg:QI (reg:DI X) 0), where UNITS_PER_WORD is the
 248              size of SImode, clobbers the first SImode part of X, and does
 249              not affect the second SImode part.  Here the QImode byte is
 250              expanded to a UNITS_PER_WORD portion of the register for
 251              purposes of determining what is clobbered.
 252
 253              If this is an rvalue, then it touches just the bytes that it
 254              talks about.  */
 255           int offset = SUBREG_BYTE (reg);
 256
 257           start = offset & ~(UNITS_PER_WORD - 1);
 258           last = (offset + m1_size + UNITS_PER_WORD - 1)
 259             & ~(UNITS_PER_WORD - 1);
 260         }
 261       else
 262         /* Whole register size M2 equal to or smaller than
 263            UNITS_PER_WORD The assignment clobbers the entire register
 264            X.  */
 265         return true;
 266     }
 267   else
 268     {
 269       /* This is an rvalue. It touches just the bytes they explicitly
 270          mentioned.  */
 271       int offset = SUBREG_BYTE (reg);
 272       start = offset;
 273       last = start + m1_size;
 274     }
 275
 276   if (dump_file)
 277     fprintf (dump_file, "    cpb subreg regno=%d start=%d last=%d\n",
 278              DF_REF_REGNO (ref), start, last);
 279
 280   *start_byte = start;
 281   *last_byte = last;
 282   return false;
 283 }
 284
 285
 286 /* Compute the set of affected bytes by a store to a pseudo to REF.
 287    MM is either DF_MM_MAY or DF_MM_MUST.  This is only relevant for
 288    the extracts which are not aligned to byte boundaries.  The
 289    DF_MM_MAY returns all of the bytes that any bit is set in and the
 290    DF_MM_MUST returns only the bytes that are completely covered.  In
 291    general DF_MM_MAY is used for uses and DF_MM_MUST is used for defs,
 292    but there are exceptions such as the inner loop of the byte level
 293    dead code eliminator which needs DF_MM_MAY for the defs to see if
 294    it any possible bit could be used.
 295
 296    If the store is to the whole register, just return TRUE, if it is
 297    to part of the register, return FALSE and set START_BYTE and
 298    LAST_BYTE properly.  In the case where fabricated uses are passed
 299    in, START_BYTE and LAST_BYTE are set to 0 and false is returned.
 300    This means that this use can be ignored.  */
 301
 302 bool
 303 df_compute_accessed_bytes (df_ref ref, enum df_mm mm,
 304                            unsigned int *start_byte,
 305                            unsigned int *last_byte)
 306 {
 307   if (!dbg_cnt (df_byte_scan))
 308     return true;
 309
 310   if (!DF_REF_REG_DEF_P (ref)
 311       && DF_REF_FLAGS_IS_SET (ref, DF_REF_READ_WRITE))
 312     {
 313       if (DF_REF_FLAGS_IS_SET (ref, DF_REF_PRE_POST_MODIFY))
 314         /* Pre/post modify/inc/dec always read and write the entire
 315            reg.  */
 316         return true;
 317       else
 318         {
 319           /* DF_REF_READ_WRITE on a use (except for the
 320              DF_REF_PRE_POST_MODIFY) means that this use is fabricated
 321              from a def that is a partial set to a multiword reg.
 322              Here, we only model those cases precisely so the only one
 323              to consider is the use put on a auto inc and dec
 324              insns.  */
 325           *start_byte = 0;
 326           *last_byte = 0;
 327           return false;
 328         }
 329     }
 330
 331   if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
 332     return df_compute_accessed_bytes_extract (ref, mm, start_byte, last_byte);
 333   else if (DF_REF_FLAGS_IS_SET (ref, DF_REF_STRICT_LOW_PART))
 334     return df_compute_accessed_bytes_strict_low_part (ref,
 335                                                       start_byte, last_byte);
 336   else if (GET_CODE (DF_REF_REG (ref)) == SUBREG)
 337     return df_compute_accessed_bytes_subreg (ref, start_byte, last_byte);
 338   return true;
 339 }
 340