Open64: osprey-gcc-4.2.0/gcc/varray.h Source File

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