Open64: osprey/kg++fe/gnu/varray.h Source File

00001 /* Virtual array support.
00002    Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
00003    Contributed by Cygnus Solutions.
00004 
00005    This file is part of GCC.
00006 
00007    GCC is free software; you can redistribute it and/or modify it
00008    under the terms of the GNU General Public License as published by
00009    the Free Software Foundation; either version 2, or (at your option)
00010    any later version.
00011 
00012    GCC is distributed in the hope that it will be useful, but WITHOUT
00013    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
00014    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
00015    License for more details.
00016 
00017    You should have received a copy of the GNU General Public License
00018    along with GCC; see the file COPYING.  If not, write to the Free
00019    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
00020    MA 02111-1307, USA.  */
00021 
00022 #ifndef GCC_VARRAY_H
00023 #define GCC_VARRAY_H
00024 
00025 #ifndef HOST_WIDE_INT
00026 #include "machmode.h"
00027 #endif
00028 
00029 #ifndef GCC_SYSTEM_H
00030 #include "system.h"
00031 #endif
00032 
00033 /* Auxiliary structure used inside the varray structure, used for
00034    function integration data.  */
00035 
00036 struct const_equiv_data GTY(()) {
00037   /* Map pseudo reg number in calling function to equivalent constant.  We
00038      cannot in general substitute constants into parameter pseudo registers,
00039      since some machine descriptions (many RISCs) won't always handle
00040      the resulting insns.  So if an incoming parameter has a constant
00041      equivalent, we record it here, and if the resulting insn is
00042      recognizable, we go with it.
00043 
00044      We also use this mechanism to convert references to incoming arguments
00045      and stacked variables.  copy_rtx_and_substitute will replace the virtual
00046      incoming argument and virtual stacked variables registers with new
00047      pseudos that contain pointers into the replacement area allocated for
00048      this inline instance.  These pseudos are then marked as being equivalent
00049      to the appropriate address and substituted if valid.  */
00050   struct rtx_def *rtx;
00051 
00052   /* Record the valid age for each entry.  The entry is invalid if its
00053      age is less than const_age.  */
00054   unsigned age;
00055 };
00056 
00057 /* Enum indicating what the varray contains.  
00058    If this is changed, `element_size' in varray.c needs to be updated.  */
00059 
00060 enum varray_data_enum {
00061   VARRAY_DATA_C,
00062   VARRAY_DATA_UC,
00063   VARRAY_DATA_S,
00064   VARRAY_DATA_US,
00065   VARRAY_DATA_I,
00066   VARRAY_DATA_U,
00067   VARRAY_DATA_L,
00068   VARRAY_DATA_UL,
00069   VARRAY_DATA_HINT,
00070   VARRAY_DATA_UHINT,
00071   VARRAY_DATA_GENERIC,
00072   VARRAY_DATA_CPTR,
00073   VARRAY_DATA_RTX,
00074   VARRAY_DATA_RTVEC,
00075   VARRAY_DATA_TREE,
00076   VARRAY_DATA_BITMAP,
00077   VARRAY_DATA_REG,
00078   VARRAY_DATA_CONST_EQUIV,
00079   VARRAY_DATA_BB,
00080   VARRAY_DATA_TE,
00081   NUM_VARRAY_DATA
00082 };
00083 
00084 /* Union of various array types that are used.  */
00085 typedef union varray_data_tag GTY (()) {
00086   char        GTY ((length ("%0.num_elements"),
00087         tag ("VARRAY_DATA_C")))   c[1];
00088   unsigned char     GTY ((length ("%0.num_elements"),
00089         tag ("VARRAY_DATA_UC")))  uc[1];
00090   short       GTY ((length ("%0.num_elements"),
00091         tag ("VARRAY_DATA_S")))   s[1];
00092   unsigned short    GTY ((length ("%0.num_elements"),
00093         tag ("VARRAY_DATA_US")))  us[1];
00094   int       GTY ((length ("%0.num_elements"),
00095         tag ("VARRAY_DATA_I")))   i[1];
00096   unsigned int      GTY ((length ("%0.num_elements"),
00097         tag ("VARRAY_DATA_U")))   u[1];
00098   long        GTY ((length ("%0.num_elements"),
00099         tag ("VARRAY_DATA_L")))   l[1];
00100   unsigned long     GTY ((length ("%0.num_elements"),
00101         tag ("VARRAY_DATA_UL")))  ul[1];
00102   HOST_WIDE_INT     GTY ((length ("%0.num_elements"),
00103         tag ("VARRAY_DATA_HINT")))  hint[1];
00104   unsigned HOST_WIDE_INT  GTY ((length ("%0.num_elements"),
00105         tag ("VARRAY_DATA_UHINT"))) uhint[1];
00106   PTR       GTY ((length ("%0.num_elements"), use_param (""),
00107         tag ("VARRAY_DATA_GENERIC"))) generic[1];
00108   char       *GTY ((length ("%0.num_elements"),
00109         tag ("VARRAY_DATA_CPTR")))  cptr[1];
00110   struct rtx_def   *GTY ((length ("%0.num_elements"),
00111         tag ("VARRAY_DATA_RTX"))) rtx[1];
00112   struct rtvec_def   *GTY ((length ("%0.num_elements"),
00113         tag ("VARRAY_DATA_RTVEC"))) rtvec[1];
00114   union tree_node  *GTY ((length ("%0.num_elements"),
00115         tag ("VARRAY_DATA_TREE")))  tree[1];
00116   struct bitmap_head_def *GTY ((length ("%0.num_elements"),
00117         tag ("VARRAY_DATA_BITMAP")))  bitmap[1];
00118   struct reg_info_def  *GTY ((length ("%0.num_elements"), skip (""),
00119         tag ("VARRAY_DATA_REG"))) reg[1];
00120   struct const_equiv_data GTY ((length ("%0.num_elements"),
00121       tag ("VARRAY_DATA_CONST_EQUIV")))   const_equiv[1];
00122   struct basic_block_def *GTY ((length ("%0.num_elements"), skip (""),
00123         tag ("VARRAY_DATA_BB")))  bb[1];
00124   struct elt_list  *GTY ((length ("%0.num_elements"),
00125         tag ("VARRAY_DATA_TE")))  te[1];
00126 } varray_data;
00127 
00128 /* Virtual array of pointers header.  */
00129 struct varray_head_tag GTY(()) {
00130   size_t  num_elements; /* Maximum element number allocated.  */
00131   size_t        elements_used;  /* The number of elements used, if
00132            using VARRAY_PUSH/VARRAY_POP.  */
00133   enum varray_data_enum type; /* The kind of elements in the varray.  */
00134   const char   *name;   /* name of the varray for reporting errors */
00135   varray_data GTY ((desc ("%0.type"))) data;  /* The data elements follow, 
00136                must be last.  */
00137 };
00138 typedef struct varray_head_tag *varray_type;
00139 
00140 /* Allocate a virtual array with NUM elements, each of which is SIZE bytes
00141    long, named NAME.  Array elements are zeroed.  */
00142 extern varray_type varray_init  PARAMS ((size_t, enum varray_data_enum, 
00143            const char *));
00144 
00145 #define VARRAY_CHAR_INIT(va, num, name) \
00146   va = varray_init (num, VARRAY_DATA_C, name)
00147 
00148 #define VARRAY_UCHAR_INIT(va, num, name) \
00149   va = varray_init (num, VARRAY_DATA_UC, name)
00150 
00151 #define VARRAY_SHORT_INIT(va, num, name) \
00152   va = varray_init (num, VARRAY_DATA_S, name)
00153 
00154 #define VARRAY_USHORT_INIT(va, num, name) \
00155   va = varray_init (num, VARRAY_DATA_US, name)
00156 
00157 #define VARRAY_INT_INIT(va, num, name) \
00158   va = varray_init (num, VARRAY_DATA_I, name)
00159 
00160 #define VARRAY_UINT_INIT(va, num, name) \
00161   va = varray_init (num, VARRAY_DATA_U, name)
00162 
00163 #define VARRAY_LONG_INIT(va, num, name) \
00164   va = varray_init (num, VARRAY_DATA_L, name)
00165 
00166 #define VARRAY_ULONG_INIT(va, num, name) \
00167   va = varray_init (num, VARRAY_DATA_UL, name)
00168 
00169 #define VARRAY_WIDE_INT_INIT(va, num, name) \
00170   va = varray_init (num, VARRAY_DATA_HINT, name)
00171 
00172 #define VARRAY_UWIDE_INT_INIT(va, num, name) \
00173   va = varray_init (num, VARRAY_DATA_UHINT, name)
00174 
00175 #define VARRAY_GENERIC_PTR_INIT(va, num, name) \
00176   va = varray_init (num, VARRAY_DATA_GENERIC, name)
00177 
00178 #define VARRAY_CHAR_PTR_INIT(va, num, name) \
00179   va = varray_init (num, VARRAY_DATA_CPTR, name)
00180 
00181 #define VARRAY_RTX_INIT(va, num, name) \
00182   va = varray_init (num, VARRAY_DATA_RTX, name)
00183 
00184 #define VARRAY_RTVEC_INIT(va, num, name) \
00185   va = varray_init (num, VARRAY_DATA_RTVEC, name)
00186 
00187 #define VARRAY_TREE_INIT(va, num, name) \
00188   va = varray_init (num, VARRAY_DATA_TREE, name)
00189 
00190 #define VARRAY_BITMAP_INIT(va, num, name) \
00191   va = varray_init (num, VARRAY_DATA_BITMAP, name)
00192 
00193 #define VARRAY_REG_INIT(va, num, name) \
00194   va = varray_init (num, VARRAY_DATA_REG, name)
00195 
00196 #define VARRAY_CONST_EQUIV_INIT(va, num, name) \
00197   va = varray_init (num, VARRAY_DATA_CONST_EQUIV, name)
00198 
00199 #define VARRAY_BB_INIT(va, num, name) \
00200   va = varray_init (num, VARRAY_DATA_BB, name)
00201 
00202 #define VARRAY_ELT_LIST_INIT(va, num, name) \
00203   va = varray_init (num, VARRAY_DATA_TE, name)
00204 
00205 /* Free up memory allocated by the virtual array, but do not free any of the
00206    elements involved.  */
00207 #define VARRAY_FREE(vp) \
00208   do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0)
00209 
00210 /* Grow/shrink the virtual array VA to N elements.  */
00211 extern varray_type varray_grow  PARAMS ((varray_type, size_t));
00212 
00213 #define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
00214 
00215 #define VARRAY_SIZE(VA) ((VA)->num_elements)
00216 
00217 #define VARRAY_ACTIVE_SIZE(VA)  ((VA)->elements_used)
00218 #define VARRAY_POP_ALL(VA)  ((VA)->elements_used = 0)
00219 
00220 #define VARRAY_CLEAR(VA) varray_clear(VA)
00221 
00222 extern void varray_clear  PARAMS ((varray_type));
00223 
00224 /* Check for VARRAY_xxx macros being in bound.  */
00225 #if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
00226 extern void varray_check_failed PARAMS ((varray_type, size_t,
00227           const char *, int,
00228           const char *)) ATTRIBUTE_NORETURN;
00229 #define VARRAY_CHECK(VA, N, T) __extension__      \
00230 (*({ varray_type const _va = (VA);        \
00231      const size_t _n = (N);           \
00232      if (_n >= _va->num_elements)       \
00233        varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \
00234      &_va->data.T[_n]; }))
00235 #else
00236 #define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
00237 #endif
00238 
00239 /* Push X onto VA.  T is the name of the field in varray_data
00240    corresponding to the type of X.  */
00241 #define VARRAY_PUSH(VA, T, X)       \
00242   do              \
00243     {             \
00244       if ((VA)->elements_used >= (VA)->num_elements)  \
00245         VARRAY_GROW ((VA), 2 * (VA)->num_elements); \
00246       (VA)->data.T[(VA)->elements_used++] = (X);  \
00247     }             \
00248   while (0)
00249 
00250 /* Pop the top element of VA.  */
00251 #define VARRAY_POP(VA) \
00252   ((VA)->elements_used--)
00253 
00254 /* Return the top element of VA.  */
00255 #define VARRAY_TOP(VA, T) \
00256   ((VA)->data.T[(VA)->elements_used - 1])
00257 
00258 #define VARRAY_CHAR(VA, N)    VARRAY_CHECK (VA, N, c)
00259 #define VARRAY_UCHAR(VA, N)   VARRAY_CHECK (VA, N, uc)
00260 #define VARRAY_SHORT(VA, N)   VARRAY_CHECK (VA, N, s)
00261 #define VARRAY_USHORT(VA, N)    VARRAY_CHECK (VA, N, us)
00262 #define VARRAY_INT(VA, N)   VARRAY_CHECK (VA, N, i)
00263 #define VARRAY_UINT(VA, N)    VARRAY_CHECK (VA, N, u)
00264 #define VARRAY_LONG(VA, N)    VARRAY_CHECK (VA, N, l)
00265 #define VARRAY_ULONG(VA, N)   VARRAY_CHECK (VA, N, ul)
00266 #define VARRAY_WIDE_INT(VA, N)    VARRAY_CHECK (VA, N, hint)
00267 #define VARRAY_UWIDE_INT(VA, N)   VARRAY_CHECK (VA, N, uhint)
00268 #define VARRAY_GENERIC_PTR(VA,N)  VARRAY_CHECK (VA, N, generic)
00269 #define VARRAY_CHAR_PTR(VA,N)   VARRAY_CHECK (VA, N, cptr)
00270 #define VARRAY_RTX(VA, N)   VARRAY_CHECK (VA, N, rtx)
00271 #define VARRAY_RTVEC(VA, N)   VARRAY_CHECK (VA, N, rtvec)
00272 #define VARRAY_TREE(VA, N)    VARRAY_CHECK (VA, N, tree)
00273 #define VARRAY_BITMAP(VA, N)    VARRAY_CHECK (VA, N, bitmap)
00274 #define VARRAY_REG(VA, N)   VARRAY_CHECK (VA, N, reg)
00275 #define VARRAY_CONST_EQUIV(VA, N) VARRAY_CHECK (VA, N, const_equiv)
00276 #define VARRAY_BB(VA, N)    VARRAY_CHECK (VA, N, bb)
00277 #define VARRAY_ELT_LIST(VA, N)    VARRAY_CHECK (VA, N, te)
00278 
00279 /* Push a new element on the end of VA, extending it if necessary.  */
00280 #define VARRAY_PUSH_CHAR(VA, X)   VARRAY_PUSH (VA, c, X)
00281 #define VARRAY_PUSH_UCHAR(VA, X)  VARRAY_PUSH (VA, uc, X)
00282 #define VARRAY_PUSH_SHORT(VA, X)  VARRAY_PUSH (VA, s, X)
00283 #define VARRAY_PUSH_USHORT(VA, X) VARRAY_PUSH (VA, us, X)
00284 #define VARRAY_PUSH_INT(VA, X)    VARRAY_PUSH (VA, i, X)
00285 #define VARRAY_PUSH_UINT(VA, X)   VARRAY_PUSH (VA, u, X)
00286 #define VARRAY_PUSH_LONG(VA, X)   VARRAY_PUSH (VA, l, X)
00287 #define VARRAY_PUSH_ULONG(VA, X)  VARRAY_PUSH (VA, ul, X)
00288 #define VARRAY_PUSH_WIDE_INT(VA, X) VARRAY_PUSH (VA, hint, X)
00289 #define VARRAY_PUSH_UWIDE_INT(VA, X)  VARRAY_PUSH (VA, uhint, X)
00290 #define VARRAY_PUSH_GENERIC_PTR(VA, X)  VARRAY_PUSH (VA, generic, X)
00291 #define VARRAY_PUSH_CHAR_PTR(VA, X) VARRAY_PUSH (VA, cptr, X)
00292 #define VARRAY_PUSH_RTX(VA, X)    VARRAY_PUSH (VA, rtx, X)
00293 #define VARRAY_PUSH_RTVEC(VA, X)  VARRAY_PUSH (VA, rtvec, X)
00294 #define VARRAY_PUSH_TREE(VA, X)   VARRAY_PUSH (VA, tree, X)
00295 #define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, bitmap, X)
00296 #define VARRAY_PUSH_REG(VA, X)    VARRAY_PUSH (VA, reg, X)
00297 #define VARRAY_PUSH_CONST_EQUIV(VA, X)  VARRAY_PUSH (VA, const_equiv, X)
00298 #define VARRAY_PUSH_BB(VA, X)   VARRAY_PUSH (VA, bb, X)
00299 
00300 /* Return the last element of VA.  */
00301 #define VARRAY_TOP_CHAR(VA)   VARRAY_TOP (VA, c)
00302 #define VARRAY_TOP_UCHAR(VA)          VARRAY_TOP (VA, uc)
00303 #define VARRAY_TOP_SHORT(VA)          VARRAY_TOP (VA, s)
00304 #define VARRAY_TOP_USHORT(VA)         VARRAY_TOP (VA, us)
00305 #define VARRAY_TOP_INT(VA)    VARRAY_TOP (VA, i)
00306 #define VARRAY_TOP_UINT(VA)   VARRAY_TOP (VA, u)
00307 #define VARRAY_TOP_LONG(VA)   VARRAY_TOP (VA, l)
00308 #define VARRAY_TOP_ULONG(VA)          VARRAY_TOP (VA, ul)
00309 #define VARRAY_TOP_WIDE_INT(VA)         VARRAY_TOP (VA, hint)
00310 #define VARRAY_TOP_UWIDE_INT(VA)  VARRAY_TOP (VA, uhint)
00311 #define VARRAY_TOP_GENERIC_PTR(VA)  VARRAY_TOP (VA, generic)
00312 #define VARRAY_TOP_CHAR_PTR(VA)   VARRAY_TOP (VA, cptr)
00313 #define VARRAY_TOP_RTX(VA)    VARRAY_TOP (VA, rtx)
00314 #define VARRAY_TOP_RTVEC(VA)          VARRAY_TOP (VA, rtvec)
00315 #define VARRAY_TOP_TREE(VA)   VARRAY_TOP (VA, tree)
00316 #define VARRAY_TOP_BITMAP(VA)         VARRAY_TOP (VA, bitmap)
00317 #define VARRAY_TOP_REG(VA)    VARRAY_TOP (VA, reg)
00318 #define VARRAY_TOP_CONST_EQUIV(VA)  VARRAY_TOP (VA, const_equiv)
00319 #define VARRAY_TOP_BB(VA)   VARRAY_TOP (VA, bb)
00320 
00321 #endif /* ! GCC_VARRAY_H */