gcc/varray.h

   1 /* Virtual array support.
   2    Copyright (C) 1998 Free Software Foundation, Inc.
   3    Contributed by Cygnus Solutions.
   4
   5    This file is part of GNU CC.
   6
   7    GNU CC 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    GNU CC is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GNU CC; see the file COPYING.  If not, write to the Free
  19    the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #ifndef _VARRAY_H_
  23 #define _VARRAY_H_
  24
  25 #ifndef PROTO
  26 #include "gansidecl.h"
  27 #endif
  28
  29 #ifndef HOST_WIDE_INT
  30 #include "machmode.h"
  31 #endif
  32
  33 #ifndef __GCC_SYSTEM_H__
  34 #include "system.h"
  35 #endif
  36
  37 /* Union of various array types that are used.  */
  38 typedef union varray_data_tag {
  39   char                   c[1];
  40   unsigned char          uc[1];
  41   short                  s[1];
  42   unsigned short         us[1];
  43   int                    i[1];
  44   unsigned int           u[1];
  45   long                   l[1];
  46   unsigned long          ul[1];
  47   HOST_WIDE_INT          hint[1];
  48   unsigned HOST_WIDE_INT uhint[1];
  49   GENERIC_PTR            generic[1];
  50   char                   *cptr[1];
  51   struct rtx_def         *rtx[1];
  52   struct rtvec_def       *rtvec[1];
  53   union tree_node        *tree[1];
  54   struct bitmap_head_def *bitmap[1];
  55   struct sched_info_tag  *sched[1];
  56   struct reg_info_def    *reg[1];
  57 } varray_data;
  58
  59 /* Virtual array of pointers header.  */
  60 typedef struct varray_head_tag {
  61   size_t        num_elements;   /* maximum element number allocated */
  62   size_t        element_size;   /* size of each data element */
  63   const char   *name;           /* name of the varray for reporting errors */
  64   varray_data   data;           /* data elements follow, must be last */
  65 } *varray_type;
  66
  67 /* Allocate a virtual array with NUM elements, each of which is SIZE bytes
  68    long, named NAME.  Array elements are zeroed.  */
  69 extern varray_type varray_init  PROTO ((size_t, size_t, const char *));
  70
  71 #define VARRAY_CHAR_INIT(va, num, name) \
  72   va = varray_init (num, sizeof (char), name)
  73
  74 #define VARRAY_UCHAR_INIT(va, num, name) \
  75   va = varray_init (num, sizeof (unsigned char), name)
  76
  77 #define VARRAY_SHORT_INIT(va, num, name) \
  78   va = varray_init (num, sizeof (short), name)
  79
  80 #define VARRAY_USHORT_INIT(va, num, name) \
  81   va = varray_init (num, sizeof (unsigned short), name)
  82
  83 #define VARRAY_INT_INIT(va, num, name) \
  84   va = varray_init (num, sizeof (int), name)
  85
  86 #define VARRAY_UINT_INIT(va, num, name) \
  87   va = varray_init (num, sizeof (unsigned int), name)
  88
  89 #define VARRAY_LONG_INIT(va, num, name) \
  90   va = varray_init (num, sizeof (long), name)
  91
  92 #define VARRAY_ULONG_INIT(va, num, name) \
  93   va = varray_init (num, sizeof (unsigned long), name)
  94
  95 #define VARRAY_WIDE_INT_INIT(va, num, name) \
  96   va = varray_init (num, sizeof (HOST_WIDE_INT), name)
  97
  98 #define VARRAY_UWIDE_INT_INIT(va, num, name) \
  99   va = varray_init (num, sizeof (unsigned HOST_WIDE_INT), name)
 100
 101 #define VARRAY_GENERIC_PTR_INIT(va, num, name) \
 102   va = varray_init (num, sizeof (GENERIC_PTR), name)
 103
 104 #define VARRAY_CHAR_PTR_INIT(va, num, name) \
 105   va = varray_init (num, sizeof (char *), name)
 106
 107 #define VARRAY_RTX_INIT(va, num, name) \
 108   va = varray_init (num, sizeof (struct rtx_def *), name)
 109
 110 #define VARRAY_RTVEC_INIT(va, num, name) \
 111   va = varray_init (num, sizeof (struct rtvec_def), name)
 112
 113 #define VARRAY_TREE_INIT(va, num, name) \
 114   va = varray_init (num, sizeof (union tree_node *), name)
 115
 116 #define VARRAY_BITMAP_INIT(va, num, name) \
 117   va = varray_init (num, sizeof (struct bitmap_head_def *), name)
 118
 119 #define VARRAY_SCHED_INIT(va, num, name) \
 120   va = varray_init (num, sizeof (struct sched_info_tag *), name)
 121
 122 #define VARRAY_REG_INIT(va, num, name) \
 123   va = varray_init (num, sizeof (struct reg_info_def *), name)
 124
 125 /* Free up memory allocated by the virtual array, but do not free any of the
 126    elements involved.  */
 127 #define VARRAY_FREE(vp) \
 128   do { if (vp) { free (vp); vp = (varray_type)0; } } while (0)
 129
 130 /* Grow/shrink the virtual array VA to N elements.  */
 131 extern varray_type varray_grow  PROTO((varray_type, size_t));
 132
 133 #define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
 134
 135 /* Check for VARRAY_xxx macros being in bound, return N for use as an
 136    index.  */
 137 #ifdef ENABLE_CHECKING
 138 #define VARRAY_CHECK(VA, N)                                             \
 139 ((((size_t)(N) < (VA)->num_elements)                                    \
 140   ? 0                                                                   \
 141   : (fatal ("Virtual array %s element %ld out of bounds, at %s:%d",     \
 142             (VA)->name, (long)(N), __FILE__, __LINE__), 0)),            \
 143  (N))
 144 #else
 145 #define VARRAY_CHECK(VA, N) (N)
 146 #endif
 147
 148 #define VARRAY_CHAR(VA, N)      ((VA)->data.c[ VARRAY_CHECK (VA, N) ])
 149 #define VARRAY_UCHAR(VA, N)     ((VA)->data.uc[ VARRAY_CHECK (VA, N) ])
 150 #define VARRAY_SHORT(VA, N)     ((VA)->data.s[ VARRAY_CHECK (VA, N) ])
 151 #define VARRAY_USHORT(VA, N)    ((VA)->data.us[ VARRAY_CHECK (VA, N) ])
 152 #define VARRAY_INT(VA, N)       ((VA)->data.i[ VARRAY_CHECK (VA, N) ])
 153 #define VARRAY_UINT(VA, N)      ((VA)->data.u[ VARRAY_CHECK (VA, N) ])
 154 #define VARRAY_LONG(VA, N)      ((VA)->data.l[ VARRAY_CHECK (VA, N) ])
 155 #define VARRAY_ULONG(VA, N)     ((VA)->data.ul[ VARRAY_CHECK (VA, N) ])
 156 #define VARRAY_WIDE_INT(VA, N)  ((VA)->data.hint[ VARRAY_CHECK (VA, N) ])
 157 #define VARRAY_UWIDE_INT(VA, N) ((VA)->data.uhint[ VARRAY_CHECK (VA, N) ])
 158 #define VARRAY_GENERIC_PTR(VA,N) ((VA)->data.generic[ VARRAY_CHECK (VA, N) ])
 159 #define VARRAY_CHAR_PTR(VA,N)   ((VA)->data.cptr[ VARRAY_CHECK (VA, N) ])
 160 #define VARRAY_RTX(VA, N)       ((VA)->data.rtx[ VARRAY_CHECK (VA, N) ])
 161 #define VARRAY_RTVEC(VA, N)     ((VA)->data.rtvec[ VARRAY_CHECK (VA, N) ])
 162 #define VARRAY_TREE(VA, N)      ((VA)->data.tree[ VARRAY_CHECK (VA, N) ])
 163 #define VARRAY_BITMAP(VA, N)    ((VA)->data.bitmap[ VARRAY_CHECK (VA, N) ])
 164 #define VARRAY_SCHED(VA, N)     ((VA)->data.sched[ VARRAY_CHECK (VA, N) ])
 165 #define VARRAY_REG(VA, N)       ((VA)->data.reg[ VARRAY_CHECK (VA, N) ])
 166
 167 #endif /* _VARRAY_H_ */