gcc/varray.h

   1 /* Virtual array support.
   2    Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
   3    Contributed by Cygnus Solutions.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  20    MA 02111-1307, USA.  */
  21
  22 #ifndef GCC_VARRAY_H
  23 #define GCC_VARRAY_H
  24
  25 #ifndef HOST_WIDE_INT
  26 #include "machmode.h"
  27 #endif
  28
  29 #ifndef GCC_SYSTEM_H
  30 #include "system.h"
  31 #endif
  32
  33 /* Auxiliary structure used inside the varray structure, used for
  34    function integration data.  */
  35
  36 struct const_equiv_data GTY(()) {
  37   /* Map pseudo reg number in calling function to equivalent constant.  We
  38      cannot in general substitute constants into parameter pseudo registers,
  39      since some machine descriptions (many RISCs) won't always handle
  40      the resulting insns.  So if an incoming parameter has a constant
  41      equivalent, we record it here, and if the resulting insn is
  42      recognizable, we go with it.
  43
  44      We also use this mechanism to convert references to incoming arguments
  45      and stacked variables.  copy_rtx_and_substitute will replace the virtual
  46      incoming argument and virtual stacked variables registers with new
  47      pseudos that contain pointers into the replacement area allocated for
  48      this inline instance.  These pseudos are then marked as being equivalent
  49      to the appropriate address and substituted if valid.  */
  50   struct rtx_def *rtx;
  51
  52   /* Record the valid age for each entry.  The entry is invalid if its
  53      age is less than const_age.  */
  54   unsigned age;
  55 };
  56
  57 /* Enum indicating what the varray contains.
  58    If this is changed, `element_size' in varray.c needs to be updated.  */
  59
  60 enum varray_data_enum {
  61   VARRAY_DATA_C,
  62   VARRAY_DATA_UC,
  63   VARRAY_DATA_S,
  64   VARRAY_DATA_US,
  65   VARRAY_DATA_I,
  66   VARRAY_DATA_U,
  67   VARRAY_DATA_L,
  68   VARRAY_DATA_UL,
  69   VARRAY_DATA_HINT,
  70   VARRAY_DATA_UHINT,
  71   VARRAY_DATA_GENERIC,
  72   VARRAY_DATA_CPTR,
  73   VARRAY_DATA_RTX,
  74   VARRAY_DATA_RTVEC,
  75   VARRAY_DATA_TREE,
  76   VARRAY_DATA_BITMAP,
  77   VARRAY_DATA_REG,
  78   VARRAY_DATA_CONST_EQUIV,
  79   VARRAY_DATA_BB,
  80   VARRAY_DATA_TE,
  81   NUM_VARRAY_DATA
  82 };
  83
  84 /* Union of various array types that are used.  */
  85 typedef union varray_data_tag GTY (()) {
  86   char                    GTY ((length ("%0.num_elements"),
  87                                 tag ("VARRAY_DATA_C")))         c[1];
  88   unsigned char           GTY ((length ("%0.num_elements"),
  89                                 tag ("VARRAY_DATA_UC")))        uc[1];
  90   short                   GTY ((length ("%0.num_elements"),
  91                                 tag ("VARRAY_DATA_S")))         s[1];
  92   unsigned short          GTY ((length ("%0.num_elements"),
  93                                 tag ("VARRAY_DATA_US")))        us[1];
  94   int                     GTY ((length ("%0.num_elements"),
  95                                 tag ("VARRAY_DATA_I")))         i[1];
  96   unsigned int            GTY ((length ("%0.num_elements"),
  97                                 tag ("VARRAY_DATA_U")))         u[1];
  98   long                    GTY ((length ("%0.num_elements"),
  99                                 tag ("VARRAY_DATA_L")))         l[1];
 100   unsigned long           GTY ((length ("%0.num_elements"),
 101                                 tag ("VARRAY_DATA_UL")))        ul[1];
 102   HOST_WIDE_INT           GTY ((length ("%0.num_elements"),
 103                                 tag ("VARRAY_DATA_HINT")))      hint[1];
 104   unsigned HOST_WIDE_INT  GTY ((length ("%0.num_elements"),
 105                                 tag ("VARRAY_DATA_UHINT")))     uhint[1];
 106   PTR                     GTY ((length ("%0.num_elements"), use_param (""),
 107                                 tag ("VARRAY_DATA_GENERIC")))   generic[1];
 108   char                   *GTY ((length ("%0.num_elements"),
 109                                 tag ("VARRAY_DATA_CPTR")))      cptr[1];
 110   struct rtx_def         *GTY ((length ("%0.num_elements"),
 111                                 tag ("VARRAY_DATA_RTX")))       rtx[1];
 112   struct rtvec_def       *GTY ((length ("%0.num_elements"),
 113                                 tag ("VARRAY_DATA_RTVEC")))     rtvec[1];
 114   union tree_node        *GTY ((length ("%0.num_elements"),
 115                                 tag ("VARRAY_DATA_TREE")))      tree[1];
 116   struct bitmap_head_def *GTY ((length ("%0.num_elements"),
 117                                 tag ("VARRAY_DATA_BITMAP")))    bitmap[1];
 118   struct reg_info_def    *GTY ((length ("%0.num_elements"), skip (""),
 119                                 tag ("VARRAY_DATA_REG")))       reg[1];
 120   struct const_equiv_data GTY ((length ("%0.num_elements"),
 121                         tag ("VARRAY_DATA_CONST_EQUIV")))       const_equiv[1];
 122   struct basic_block_def *GTY ((length ("%0.num_elements"), skip (""),
 123                                 tag ("VARRAY_DATA_BB")))        bb[1];
 124   struct elt_list        *GTY ((length ("%0.num_elements"),
 125                                 tag ("VARRAY_DATA_TE")))        te[1];
 126 } varray_data;
 127
 128 /* Virtual array of pointers header.  */
 129 struct varray_head_tag GTY(()) {
 130   size_t        num_elements;   /* Maximum element number allocated.  */
 131   size_t        elements_used;  /* The number of elements used, if
 132                                    using VARRAY_PUSH/VARRAY_POP.  */
 133   enum varray_data_enum type;   /* The kind of elements in the varray.  */
 134   const char   *name;           /* name of the varray for reporting errors */
 135   varray_data   GTY ((desc ("%0.type"))) data;  /* The data elements follow,
 136                                                    must be last.  */
 137 };
 138 typedef struct varray_head_tag *varray_type;
 139
 140 /* Allocate a virtual array with NUM elements, each of which is SIZE bytes
 141    long, named NAME.  Array elements are zeroed.  */
 142 extern varray_type varray_init  PARAMS ((size_t, enum varray_data_enum,
 143                                          const char *));
 144
 145 #define VARRAY_CHAR_INIT(va, num, name) \
 146   va = varray_init (num, VARRAY_DATA_C, name)
 147
 148 #define VARRAY_UCHAR_INIT(va, num, name) \
 149   va = varray_init (num, VARRAY_DATA_UC, name)
 150
 151 #define VARRAY_SHORT_INIT(va, num, name) \
 152   va = varray_init (num, VARRAY_DATA_S, name)
 153
 154 #define VARRAY_USHORT_INIT(va, num, name) \
 155   va = varray_init (num, VARRAY_DATA_US, name)
 156
 157 #define VARRAY_INT_INIT(va, num, name) \
 158   va = varray_init (num, VARRAY_DATA_I, name)
 159
 160 #define VARRAY_UINT_INIT(va, num, name) \
 161   va = varray_init (num, VARRAY_DATA_U, name)
 162
 163 #define VARRAY_LONG_INIT(va, num, name) \
 164   va = varray_init (num, VARRAY_DATA_L, name)
 165
 166 #define VARRAY_ULONG_INIT(va, num, name) \
 167   va = varray_init (num, VARRAY_DATA_UL, name)
 168
 169 #define VARRAY_WIDE_INT_INIT(va, num, name) \
 170   va = varray_init (num, VARRAY_DATA_HINT, name)
 171
 172 #define VARRAY_UWIDE_INT_INIT(va, num, name) \
 173   va = varray_init (num, VARRAY_DATA_UHINT, name)
 174
 175 #define VARRAY_GENERIC_PTR_INIT(va, num, name) \
 176   va = varray_init (num, VARRAY_DATA_GENERIC, name)
 177
 178 #define VARRAY_CHAR_PTR_INIT(va, num, name) \
 179   va = varray_init (num, VARRAY_DATA_CPTR, name)
 180
 181 #define VARRAY_RTX_INIT(va, num, name) \
 182   va = varray_init (num, VARRAY_DATA_RTX, name)
 183
 184 #define VARRAY_RTVEC_INIT(va, num, name) \
 185   va = varray_init (num, VARRAY_DATA_RTVEC, name)
 186
 187 #define VARRAY_TREE_INIT(va, num, name) \
 188   va = varray_init (num, VARRAY_DATA_TREE, name)
 189
 190 #define VARRAY_BITMAP_INIT(va, num, name) \
 191   va = varray_init (num, VARRAY_DATA_BITMAP, name)
 192
 193 #define VARRAY_REG_INIT(va, num, name) \
 194   va = varray_init (num, VARRAY_DATA_REG, name)
 195
 196 #define VARRAY_CONST_EQUIV_INIT(va, num, name) \
 197   va = varray_init (num, VARRAY_DATA_CONST_EQUIV, name)
 198
 199 #define VARRAY_BB_INIT(va, num, name) \
 200   va = varray_init (num, VARRAY_DATA_BB, name)
 201
 202 #define VARRAY_ELT_LIST_INIT(va, num, name) \
 203   va = varray_init (num, VARRAY_DATA_TE, name)
 204
 205 /* Free up memory allocated by the virtual array, but do not free any of the
 206    elements involved.  */
 207 #define VARRAY_FREE(vp) \
 208   do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0)
 209
 210 /* Grow/shrink the virtual array VA to N elements.  */
 211 extern varray_type varray_grow  PARAMS ((varray_type, size_t));
 212
 213 #define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
 214
 215 #define VARRAY_SIZE(VA) ((VA)->num_elements)
 216
 217 #define VARRAY_ACTIVE_SIZE(VA)  ((VA)->elements_used)
 218 #define VARRAY_POP_ALL(VA)      ((VA)->elements_used = 0)
 219
 220 #define VARRAY_CLEAR(VA) varray_clear(VA)
 221
 222 extern void varray_clear        PARAMS ((varray_type));
 223
 224 /* Check for VARRAY_xxx macros being in bound.  */
 225 #if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
 226 extern void varray_check_failed PARAMS ((varray_type, size_t,
 227                                         const char *, int,
 228                                         const char *)) ATTRIBUTE_NORETURN;
 229 #define VARRAY_CHECK(VA, N, T) __extension__                    \
 230 (*({ varray_type const _va = (VA);                              \
 231      const size_t _n = (N);                                     \
 232      if (_n >= _va->num_elements)                               \
 233        varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \
 234      &_va->data.T[_n]; }))
 235 #else
 236 #define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
 237 #endif
 238
 239 /* Push X onto VA.  T is the name of the field in varray_data
 240    corresponding to the type of X.  */
 241 #define VARRAY_PUSH(VA, T, X)                           \
 242   do                                                    \
 243     {                                                   \
 244       if ((VA)->elements_used >= (VA)->num_elements)    \
 245         VARRAY_GROW ((VA), 2 * (VA)->num_elements);     \
 246       (VA)->data.T[(VA)->elements_used++] = (X);        \
 247     }                                                   \
 248   while (0)
 249
 250 /* Pop the top element of VA.  */
 251 #define VARRAY_POP(VA) \
 252   ((VA)->elements_used--)
 253
 254 /* Return the top element of VA.  */
 255 #define VARRAY_TOP(VA, T) \
 256   ((VA)->data.T[(VA)->elements_used - 1])
 257
 258 #define VARRAY_CHAR(VA, N)              VARRAY_CHECK (VA, N, c)
 259 #define VARRAY_UCHAR(VA, N)             VARRAY_CHECK (VA, N, uc)
 260 #define VARRAY_SHORT(VA, N)             VARRAY_CHECK (VA, N, s)
 261 #define VARRAY_USHORT(VA, N)            VARRAY_CHECK (VA, N, us)
 262 #define VARRAY_INT(VA, N)               VARRAY_CHECK (VA, N, i)
 263 #define VARRAY_UINT(VA, N)              VARRAY_CHECK (VA, N, u)
 264 #define VARRAY_LONG(VA, N)              VARRAY_CHECK (VA, N, l)
 265 #define VARRAY_ULONG(VA, N)             VARRAY_CHECK (VA, N, ul)
 266 #define VARRAY_WIDE_INT(VA, N)          VARRAY_CHECK (VA, N, hint)
 267 #define VARRAY_UWIDE_INT(VA, N)         VARRAY_CHECK (VA, N, uhint)
 268 #define VARRAY_GENERIC_PTR(VA,N)        VARRAY_CHECK (VA, N, generic)
 269 #define VARRAY_CHAR_PTR(VA,N)           VARRAY_CHECK (VA, N, cptr)
 270 #define VARRAY_RTX(VA, N)               VARRAY_CHECK (VA, N, rtx)
 271 #define VARRAY_RTVEC(VA, N)             VARRAY_CHECK (VA, N, rtvec)
 272 #define VARRAY_TREE(VA, N)              VARRAY_CHECK (VA, N, tree)
 273 #define VARRAY_BITMAP(VA, N)            VARRAY_CHECK (VA, N, bitmap)
 274 #define VARRAY_REG(VA, N)               VARRAY_CHECK (VA, N, reg)
 275 #define VARRAY_CONST_EQUIV(VA, N)       VARRAY_CHECK (VA, N, const_equiv)
 276 #define VARRAY_BB(VA, N)                VARRAY_CHECK (VA, N, bb)
 277 #define VARRAY_ELT_LIST(VA, N)          VARRAY_CHECK (VA, N, te)
 278
 279 /* Push a new element on the end of VA, extending it if necessary.  */
 280 #define VARRAY_PUSH_CHAR(VA, X)         VARRAY_PUSH (VA, c, X)
 281 #define VARRAY_PUSH_UCHAR(VA, X)        VARRAY_PUSH (VA, uc, X)
 282 #define VARRAY_PUSH_SHORT(VA, X)        VARRAY_PUSH (VA, s, X)
 283 #define VARRAY_PUSH_USHORT(VA, X)       VARRAY_PUSH (VA, us, X)
 284 #define VARRAY_PUSH_INT(VA, X)          VARRAY_PUSH (VA, i, X)
 285 #define VARRAY_PUSH_UINT(VA, X)         VARRAY_PUSH (VA, u, X)
 286 #define VARRAY_PUSH_LONG(VA, X)         VARRAY_PUSH (VA, l, X)
 287 #define VARRAY_PUSH_ULONG(VA, X)        VARRAY_PUSH (VA, ul, X)
 288 #define VARRAY_PUSH_WIDE_INT(VA, X)     VARRAY_PUSH (VA, hint, X)
 289 #define VARRAY_PUSH_UWIDE_INT(VA, X)    VARRAY_PUSH (VA, uhint, X)
 290 #define VARRAY_PUSH_GENERIC_PTR(VA, X)  VARRAY_PUSH (VA, generic, X)
 291 #define VARRAY_PUSH_CHAR_PTR(VA, X)     VARRAY_PUSH (VA, cptr, X)
 292 #define VARRAY_PUSH_RTX(VA, X)          VARRAY_PUSH (VA, rtx, X)
 293 #define VARRAY_PUSH_RTVEC(VA, X)        VARRAY_PUSH (VA, rtvec, X)
 294 #define VARRAY_PUSH_TREE(VA, X)         VARRAY_PUSH (VA, tree, X)
 295 #define VARRAY_PUSH_BITMAP(VA, X)       VARRAY_PUSH (VA, bitmap, X)
 296 #define VARRAY_PUSH_REG(VA, X)          VARRAY_PUSH (VA, reg, X)
 297 #define VARRAY_PUSH_CONST_EQUIV(VA, X)  VARRAY_PUSH (VA, const_equiv, X)
 298 #define VARRAY_PUSH_BB(VA, X)           VARRAY_PUSH (VA, bb, X)
 299
 300 /* Return the last element of VA.  */
 301 #define VARRAY_TOP_CHAR(VA)             VARRAY_TOP (VA, c)
 302 #define VARRAY_TOP_UCHAR(VA)            VARRAY_TOP (VA, uc)
 303 #define VARRAY_TOP_SHORT(VA)            VARRAY_TOP (VA, s)
 304 #define VARRAY_TOP_USHORT(VA)           VARRAY_TOP (VA, us)
 305 #define VARRAY_TOP_INT(VA)              VARRAY_TOP (VA, i)
 306 #define VARRAY_TOP_UINT(VA)             VARRAY_TOP (VA, u)
 307 #define VARRAY_TOP_LONG(VA)             VARRAY_TOP (VA, l)
 308 #define VARRAY_TOP_ULONG(VA)            VARRAY_TOP (VA, ul)
 309 #define VARRAY_TOP_WIDE_INT(VA)         VARRAY_TOP (VA, hint)
 310 #define VARRAY_TOP_UWIDE_INT(VA)        VARRAY_TOP (VA, uhint)
 311 #define VARRAY_TOP_GENERIC_PTR(VA)      VARRAY_TOP (VA, generic)
 312 #define VARRAY_TOP_CHAR_PTR(VA)         VARRAY_TOP (VA, cptr)
 313 #define VARRAY_TOP_RTX(VA)              VARRAY_TOP (VA, rtx)
 314 #define VARRAY_TOP_RTVEC(VA)            VARRAY_TOP (VA, rtvec)
 315 #define VARRAY_TOP_TREE(VA)             VARRAY_TOP (VA, tree)
 316 #define VARRAY_TOP_BITMAP(VA)           VARRAY_TOP (VA, bitmap)
 317 #define VARRAY_TOP_REG(VA)              VARRAY_TOP (VA, reg)
 318 #define VARRAY_TOP_CONST_EQUIV(VA)      VARRAY_TOP (VA, const_equiv)
 319 #define VARRAY_TOP_BB(VA)               VARRAY_TOP (VA, bb)
 320
 321 #endif /* ! GCC_VARRAY_H */