$(MACHMODE_H) tree-check.h $(BUILTINS_DEF) \
$(INPUT_H) statistics.h vec.h treestruct.def $(HASHTAB_H) \
double-int.h alias.h $(SYMTAB_H) options.h
-BASIC_BLOCK_H = basic-block.h $(BITMAP_H) sbitmap.h varray.h $(PARTITION_H) \
+BASIC_BLOCK_H = basic-block.h $(BITMAP_H) sbitmap.h $(PARTITION_H) \
hard-reg-set.h $(PREDICT_H) vec.h $(FUNCTION_H) \
cfghooks.h $(OBSTACK_H)
GIMPLE_H = gimple.h gimple.def gsstruct.def pointer-set.h vec.h \
FUNCTION_H = function.h $(TREE_H) $(HASHTAB_H) vecprim.h
EXPR_H = expr.h insn-config.h $(FUNCTION_H) $(RTL_H) $(FLAGS_H) $(TREE_H) $(MACHMODE_H) $(EMIT_RTL_H)
OPTABS_H = optabs.h insn-codes.h
-REGS_H = regs.h varray.h $(MACHMODE_H) $(OBSTACK_H) $(BASIC_BLOCK_H) $(FUNCTION_H)
+REGS_H = regs.h $(MACHMODE_H) $(OBSTACK_H) $(BASIC_BLOCK_H) $(FUNCTION_H)
RESOURCE_H = resource.h hard-reg-set.h
SCHED_INT_H = sched-int.h $(INSN_ATTR_H) $(BASIC_BLOCK_H) $(RTL_H) $(DF_H) vecprim.h
SEL_SCHED_IR_H = sel-sched-ir.h $(INSN_ATTR_H) $(BASIC_BLOCK_H) $(RTL_H) \
GCC_H = gcc.h version.h
GGC_H = ggc.h gtype-desc.h statistics.h
TIMEVAR_H = timevar.h timevar.def
-INSN_ATTR_H = insn-attr.h $(INSN_ADDR_H) $(srcdir)/varray.h
+INSN_ATTR_H = insn-attr.h $(INSN_ADDR_H)
INSN_ADDR_H = $(srcdir)/insn-addr.h vecprim.h
C_COMMON_H = c-common.h $(SPLAY_TREE_H) $(CPPLIB_H) $(GGC_H)
C_PRAGMA_H = c-pragma.h $(CPPLIB_H)
SCEV_H = tree-scalar-evolution.h $(GGC_H) tree-chrec.h $(PARAMS_H)
LAMBDA_H = lambda.h $(TREE_H) vec.h $(GGC_H)
TREE_DATA_REF_H = tree-data-ref.h $(LAMBDA_H) omega.h graphds.h $(SCEV_H)
-VARRAY_H = varray.h $(MACHMODE_H) $(SYSTEM_H) coretypes.h $(TM_H)
TREE_INLINE_H = tree-inline.h $(GIMPLE_H)
REAL_H = real.h $(MACHMODE_H)
IRA_INT_H = ira.h ira-int.h $(CFGLOOP_H) alloc-pool.h
value-prof.o \
var-tracking.o \
varasm.o \
- varray.o \
vec.o \
version.o \
vmsdbgout.o \
-DBUGURL=$(BUGURL_s) -c $(srcdir)/version.c $(OUTPUT_OPTION)
gtype-desc.o: gtype-desc.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
- $(VARRAY_H) $(HASHTAB_H) $(SPLAY_TREE_H) $(OBSTACK_H) $(BITMAP_H) \
+ $(HASHTAB_H) $(SPLAY_TREE_H) $(OBSTACK_H) $(BITMAP_H) \
$(INPUT_H) $(TREE_H) $(RTL_H) $(FUNCTION_H) insn-config.h $(EXPR_H) \
hard-reg-set.h $(BASIC_BLOCK_H) cselib.h $(INSN_ADDR_H) $(OPTABS_H) \
libfuncs.h debug.h $(GGC_H) $(CGRAPH_H) $(TREE_FLOW_H) reload.h \
tree-ssa-structalias.o: tree-ssa-structalias.c \
$(SYSTEM_H) $(CONFIG_H) coretypes.h $(TM_H) $(GGC_H) $(OBSTACK_H) $(BITMAP_H) \
$(FLAGS_H) $(RTL_H) $(TM_P_H) hard-reg-set.h $(BASIC_BLOCK_H) output.h \
- $(DIAGNOSTIC_H) $(TOPLEV_H) $(TREE_H) $(TREE_FLOW_H) $(TREE_INLINE_H) varray.h \
+ $(DIAGNOSTIC_H) $(TOPLEV_H) $(TREE_H) $(TREE_FLOW_H) $(TREE_INLINE_H) \
$(GIMPLE_H) $(HASHTAB_H) $(FUNCTION_H) $(CGRAPH_H) \
$(TREE_PASS_H) $(TIMEVAR_H) alloc-pool.h $(SPLAY_TREE_H) $(PARAMS_H) \
gt-tree-ssa-structalias.h $(CGRAPH_H) $(ALIAS_H) pointer-set.h
$(TREE_H) $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(HASHTAB_H) \
$(TM_H) coretypes.h
omega.o : omega.c omega.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
- $(GGC_H) $(TREE_H) $(DIAGNOSTIC_H) varray.h $(TREE_PASS_H) $(PARAMS_H)
+ $(GGC_H) $(TREE_H) $(DIAGNOSTIC_H) $(TREE_PASS_H) $(PARAMS_H)
tree-chrec.o: tree-chrec.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(GGC_H) $(TREE_H) $(REAL_H) $(SCEV_H) $(TREE_PASS_H) $(PARAMS_H) \
$(DIAGNOSTIC_H) $(CFGLOOP_H) $(TREE_FLOW_H) $(FLAGS_H)
opts.o : opts.c opts.h options.h $(TOPLEV_H) $(CONFIG_H) $(SYSTEM_H) \
coretypes.h $(TREE_H) $(TM_H) langhooks.h $(GGC_H) $(EXPR_H) $(RTL_H) \
output.h $(DIAGNOSTIC_H) $(TM_P_H) $(INSN_ATTR_H) intl.h $(TARGET_H) \
- $(FLAGS_H) $(PARAMS_H) $(TREE_PASS_H) $(DBGCNT_H) debug.h varray.h \
+ $(FLAGS_H) $(PARAMS_H) $(TREE_PASS_H) $(DBGCNT_H) debug.h \
$(PLUGIN_H) $(EXCEPT_H)
opts-common.o : opts-common.c opts.h $(CONFIG_H) $(SYSTEM_H) \
coretypes.h intl.h
langhooks.h insn-flags.h $(CFGLAYOUT_H) $(CFGLOOP_H) hosthooks.h \
$(CGRAPH_H) $(COVERAGE_H) alloc-pool.h $(GGC_H) $(INTEGRATE_H) \
opts.h params.def tree-mudflap.h $(REAL_H) $(TREE_PASS_H) $(GIMPLE_H) \
- tree-ssa-alias.h $(PLUGIN_H) $(VARRAY_H)
+ tree-ssa-alias.h $(PLUGIN_H)
$(COMPILER) $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) \
-DTARGET_NAME=\"$(target_noncanonical)\" \
-c $(srcdir)/toplev.c $(OUTPUT_OPTION)
rtl-error.o: rtl-error.c $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(INSN_ATTR_H) insn-config.h $(INPUT_H) $(TOPLEV_H) intl.h $(DIAGNOSTIC_H) \
- $(CONFIG_H) varray.h
+ $(CONFIG_H)
rtl.o : rtl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(GGC_H) $(BCONFIG_H) insn-notes.def reg-notes.def $(TOPLEV_H) $(REAL_H)
sdbout.o : sdbout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) debug.h \
$(TREE_H) $(GGC_H) $(RTL_H) $(REGS_H) $(FLAGS_H) insn-config.h \
output.h $(TOPLEV_H) $(TM_P_H) gsyms.h langhooks.h $(TARGET_H) sdbout.h \
- gt-sdbout.h reload.h $(VARRAY_H)
+ gt-sdbout.h reload.h
dwarf2out.o : dwarf2out.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(TREE_H) version.h $(RTL_H) $(DWARF2_H) debug.h $(FLAGS_H) insn-config.h \
output.h $(DIAGNOSTIC_H) $(REAL_H) hard-reg-set.h $(REGS_H) $(EXPR_H) \
$(TARGET_H) $(TREE_PASS_H) $(DF_H) ira.h
bitmap.o : bitmap.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(FLAGS_H) $(GGC_H) gt-bitmap.h $(BITMAP_H) $(OBSTACK_H) $(HASHTAB_H)
-varray.o : varray.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(GGC_H) \
- $(HASHTAB_H) $(BCONFIG_H) $(VARRAY_H) $(TOPLEV_H)
vec.o : vec.c $(CONFIG_H) $(SYSTEM_H) coretypes.h vec.h $(GGC_H) \
$(TOPLEV_H) $(HASHTAB_H)
reload.o : reload.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(tm_file_list) $(HASHTAB_H) $(SPLAY_TREE_H) $(srcdir)/bitmap.h \
$(srcdir)/alias.h $(srcdir)/coverage.c $(srcdir)/rtl.h \
$(srcdir)/vecprim.h \
- $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/varray.h $(srcdir)/libfuncs.h $(SYMTAB_H) \
+ $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/libfuncs.h $(SYMTAB_H) \
$(srcdir)/real.h $(srcdir)/function.h $(srcdir)/insn-addr.h $(srcdir)/hwint.h \
$(srcdir)/fixed-value.h \
$(srcdir)/ipa-reference.h $(srcdir)/output.h $(srcdir)/cfgloop.h \
+++ /dev/null
-/* Virtual array support.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008
- Free Software Foundation, Inc.
- Contributed by Cygnus Solutions.
-
- This file is part of GCC.
-
- GCC is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3, or (at your option)
- any later version.
-
- GCC is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
- License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GCC; see the file COPYING3. If not see
- <http://www.gnu.org/licenses/>. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "toplev.h"
-#include "varray.h"
-#include "ggc.h"
-#include "hashtab.h"
-
-#define VARRAY_HDR_SIZE (sizeof (struct varray_head_tag) - sizeof (varray_data))
-
-#ifdef GATHER_STATISTICS
-
-/* Store information about each particular varray. */
-struct varray_descriptor
-{
- const char *name;
- int allocated;
- int created;
- int resized;
- int copied;
-};
-
-/* Hashtable mapping varray names to descriptors. */
-static htab_t varray_hash;
-
-/* Hashtable helpers. */
-static hashval_t
-hash_descriptor (const void *p)
-{
- const struct varray_descriptor *d = (const struct varray_descriptor *) p;
- return htab_hash_pointer (d->name);
-}
-static int
-eq_descriptor (const void *p1, const void *p2)
-{
- const struct varray_descriptor *d = (const struct varray_descriptor *) p1;
- return d->name == p2;
-}
-
-/* For given name, return descriptor, create new if needed. */
-static struct varray_descriptor *
-varray_descriptor (const char *name)
-{
- struct varray_descriptor **slot;
-
- if (!varray_hash)
- varray_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
-
- slot = (struct varray_descriptor **)
- htab_find_slot_with_hash (varray_hash, name,
- htab_hash_pointer (name),
- INSERT);
- if (*slot)
- return *slot;
- *slot = XCNEW (struct varray_descriptor);
- (*slot)->name = name;
- return *slot;
-}
-#endif
-
-/* Do not add any more non-GC items here. Please either remove or GC
- those items that are not GCed. */
-
-static const struct {
- unsigned char size;
- bool uses_ggc;
-} element[NUM_VARRAY_DATA] = {
- { sizeof (char), 1 },
- { sizeof (unsigned char), 1 },
- { sizeof (short), 1 },
- { sizeof (unsigned short), 1 },
- { sizeof (int), 1 },
- { sizeof (unsigned int), 1 },
- { sizeof (long), 1 },
- { sizeof (unsigned long), 1 },
- { sizeof (HOST_WIDE_INT), 1 },
- { sizeof (unsigned HOST_WIDE_INT), 1 },
- { sizeof (void *), 1 },
- { sizeof (void *), 0 },
- { sizeof (char *), 1 },
- { sizeof (struct rtx_def *), 1 },
- { sizeof (struct rtvec_def *), 1 },
- { sizeof (union tree_node *), 1 },
- { sizeof (struct bitmap_head_def *), 1 },
- { sizeof (struct reg_info_def *), 0 },
- { sizeof (struct basic_block_def *), 1 },
- { sizeof (struct elt_list *), 1 },
- { sizeof (struct edge_def *), 1 },
- { sizeof (tree *), 1 },
-};
-
-/* Allocate a virtual array with NUM_ELEMENT elements, each of which is
- ELEMENT_SIZE bytes long, named NAME. Array elements are zeroed. */
-varray_type
-varray_init (size_t num_elements, enum varray_data_enum element_kind,
- const char *name)
-{
- size_t data_size = num_elements * element[element_kind].size;
- varray_type ptr;
-#ifdef GATHER_STATISTICS
- struct varray_descriptor *desc = varray_descriptor (name);
-
- desc->created++;
- desc->allocated += data_size + VARRAY_HDR_SIZE;
-#endif
- if (element[element_kind].uses_ggc)
- ptr = GGC_CNEWVAR (struct varray_head_tag, VARRAY_HDR_SIZE + data_size);
- else
- ptr = XCNEWVAR (struct varray_head_tag, VARRAY_HDR_SIZE + data_size);
-
- ptr->num_elements = num_elements;
- ptr->elements_used = 0;
- ptr->type = element_kind;
- ptr->name = name;
- return ptr;
-}
-
-/* Grow/shrink the virtual array VA to N elements. Zero any new elements
- allocated. */
-varray_type
-varray_grow (varray_type va, size_t n)
-{
- size_t old_elements = va->num_elements;
- if (n != old_elements)
- {
- size_t elem_size = element[va->type].size;
- size_t old_data_size = old_elements * elem_size;
- size_t data_size = n * elem_size;
-#ifdef GATHER_STATISTICS
- struct varray_descriptor *desc = varray_descriptor (va->name);
- varray_type oldva = va;
-
- if (data_size > old_data_size)
- desc->allocated += data_size - old_data_size;
- desc->resized ++;
-#endif
-
-
- if (element[va->type].uses_ggc)
- va = GGC_RESIZEVAR (struct varray_head_tag, va,
- VARRAY_HDR_SIZE + data_size);
- else
- va = XRESIZEVAR (struct varray_head_tag, va,
- VARRAY_HDR_SIZE + data_size);
- va->num_elements = n;
- if (n > old_elements)
- memset (&va->data.vdt_c[old_data_size], 0, data_size - old_data_size);
-#ifdef GATHER_STATISTICS
- if (oldva != va)
- desc->copied++;
-#endif
- }
-
- return va;
-}
-
-/* Reset a varray to its original state. */
-void
-varray_clear (varray_type va)
-{
- size_t data_size = element[va->type].size * va->num_elements;
-
- memset (va->data.vdt_c, 0, data_size);
- va->elements_used = 0;
-}
-
-/* Check the bounds of a varray access. */
-
-#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
-
-void
-varray_check_failed (varray_type va, size_t n, const char *file, int line,
- const char *function)
-{
- internal_error ("virtual array %s[%lu]: element %lu out of bounds "
- "in %s, at %s:%d",
- va->name, (unsigned long) va->num_elements, (unsigned long) n,
- function, trim_filename (file), line);
-}
-
-void
-varray_underflow (varray_type va, const char *file, int line,
- const char *function)
-{
- internal_error ("underflowed virtual array %s in %s, at %s:%d",
- va->name, function, trim_filename (file), line);
-}
-
-#endif
-
-
-/* Output per-varray statistics. */
-#ifdef GATHER_STATISTICS
-
-/* Used to accumulate statistics about varray sizes. */
-struct output_info
-{
- int count;
- int size;
-};
-
-/* Called via htab_traverse. Output varray descriptor pointed out by SLOT
- and update statistics. */
-static int
-print_statistics (void **slot, void *b)
-{
- struct varray_descriptor *d = (struct varray_descriptor *) *slot;
- struct output_info *i = (struct output_info *) b;
-
- if (d->allocated)
- {
- fprintf (stderr, "%-21s %6d %10d %7d %7d\n", d->name,
- d->created, d->allocated, d->resized, d->copied);
- i->size += d->allocated;
- i->count += d->created;
- }
- return 1;
-}
-#endif
-
-/* Output per-varray memory usage statistics. */
-void
-dump_varray_statistics (void)
-{
-#ifdef GATHER_STATISTICS
- struct output_info info;
-
- if (varray_hash)
- {
- fprintf (stderr, "\nVARRAY Kind Count Bytes Resized copied\n");
- fprintf (stderr, "-------------------------------------------------------\n");
- info.count = 0;
- info.size = 0;
- htab_traverse (varray_hash, print_statistics, &info);
- fprintf (stderr, "-------------------------------------------------------\n");
- fprintf (stderr, "%-20s %7d %10d\n",
- "Total", info.count, info.size);
- fprintf (stderr, "-------------------------------------------------------\n");
- }
-#endif
-}
+++ /dev/null
-/* Virtual array support.
- Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2007
- Free Software Foundation, Inc.
- Contributed by Cygnus Solutions.
-
- This file is part of GCC.
-
- GCC is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3, or (at your option)
- any later version.
-
- GCC is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
- License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GCC; see the file COPYING3. If not see
- <http://www.gnu.org/licenses/>. */
-
-#ifndef GCC_VARRAY_H
-#define GCC_VARRAY_H
-
-#ifndef HOST_WIDE_INT
-#include "machmode.h"
-#endif
-
-#ifndef GCC_SYSTEM_H
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#endif
-
-/* Enum indicating what the varray contains.
- If this is changed, `element' in varray.c needs to be updated. */
-
-enum varray_data_enum {
- VARRAY_DATA_C,
- VARRAY_DATA_UC,
- VARRAY_DATA_S,
- VARRAY_DATA_US,
- VARRAY_DATA_I,
- VARRAY_DATA_U,
- VARRAY_DATA_L,
- VARRAY_DATA_UL,
- VARRAY_DATA_HINT,
- VARRAY_DATA_UHINT,
- VARRAY_DATA_GENERIC,
- VARRAY_DATA_GENERIC_NOGC,
- VARRAY_DATA_CPTR,
- VARRAY_DATA_RTX,
- VARRAY_DATA_RTVEC,
- VARRAY_DATA_TREE,
- VARRAY_DATA_BITMAP,
- VARRAY_DATA_REG,
- VARRAY_DATA_BB,
- VARRAY_DATA_TE,
- VARRAY_DATA_EDGE,
- VARRAY_DATA_TREE_PTR,
- NUM_VARRAY_DATA
-};
-
-/* Union of various array types that are used. */
-typedef union GTY (()) varray_data_tag {
- char GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_C"))) vdt_c[1];
- unsigned char GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_UC"))) vdt_uc[1];
- short GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_S"))) vdt_s[1];
- unsigned short GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_US"))) vdt_us[1];
- int GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_I"))) vdt_i[1];
- unsigned int GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_U"))) vdt_u[1];
- long GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_L"))) vdt_l[1];
- unsigned long GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_UL"))) vdt_ul[1];
- HOST_WIDE_INT GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_HINT"))) vdt_hint[1];
- unsigned HOST_WIDE_INT GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_UHINT"))) vdt_uhint[1];
- PTR GTY ((length ("%0.num_elements"), use_param,
- tag ("VARRAY_DATA_GENERIC"))) vdt_generic[1];
- PTR GTY ((length ("%0.num_elements"), skip (""),
- tag ("VARRAY_DATA_GENERIC_NOGC"))) vdt_generic_nogc[1];
- char *GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_CPTR"))) vdt_cptr[1];
- rtx GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_RTX"))) vdt_rtx[1];
- rtvec GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_RTVEC"))) vdt_rtvec[1];
- tree GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_TREE"))) vdt_tree[1];
- struct bitmap_head_def *GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_BITMAP"))) vdt_bitmap[1];
- struct reg_info_def *GTY ((length ("%0.num_elements"), skip,
- tag ("VARRAY_DATA_REG"))) vdt_reg[1];
- struct basic_block_def *GTY ((length ("%0.num_elements"), skip,
- tag ("VARRAY_DATA_BB"))) vdt_bb[1];
- struct elt_list *GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_TE"))) vdt_te[1];
- struct edge_def *GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_EDGE"))) vdt_e[1];
- tree *GTY ((length ("%0.num_elements"), skip (""),
- tag ("VARRAY_DATA_TREE_PTR"))) vdt_tp[1];
-} varray_data;
-
-/* Virtual array of pointers header. */
-struct GTY(()) varray_head_tag {
- size_t num_elements; /* Maximum element number allocated. */
- size_t elements_used; /* The number of elements used, if
- using VARRAY_PUSH/VARRAY_POP. */
- enum varray_data_enum type; /* The kind of elements in the varray. */
- const char *name; /* name of the varray for reporting errors */
- varray_data GTY ((desc ("%0.type"))) data; /* The data elements follow,
- must be last. */
-};
-typedef struct varray_head_tag *varray_type;
-
-/* Allocate a virtual array with NUM elements, each of which is SIZE bytes
- long, named NAME. Array elements are zeroed. */
-extern varray_type varray_init (size_t, enum varray_data_enum, const char *);
-
-#define VARRAY_CHAR_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_C, name)
-
-#define VARRAY_UCHAR_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_UC, name)
-
-#define VARRAY_SHORT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_S, name)
-
-#define VARRAY_USHORT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_US, name)
-
-#define VARRAY_INT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_I, name)
-
-#define VARRAY_UINT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_U, name)
-
-#define VARRAY_LONG_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_L, name)
-
-#define VARRAY_ULONG_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_UL, name)
-
-#define VARRAY_WIDE_INT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_HINT, name)
-
-#define VARRAY_UWIDE_INT_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_UHINT, name)
-
-#define VARRAY_GENERIC_PTR_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_GENERIC, name)
-
-#define VARRAY_GENERIC_PTR_NOGC_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_GENERIC_NOGC, name)
-
-#define VARRAY_CHAR_PTR_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_CPTR, name)
-
-#define VARRAY_RTX_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_RTX, name)
-
-#define VARRAY_RTVEC_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_RTVEC, name)
-
-#define VARRAY_TREE_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_TREE, name)
-
-#define VARRAY_BITMAP_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_BITMAP, name)
-
-#define VARRAY_REG_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_REG, name)
-
-#define VARRAY_BB_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_BB, name)
-
-#define VARRAY_ELT_LIST_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_TE, name)
-
-#define VARRAY_EDGE_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_EDGE, name)
-
-#define VARRAY_TREE_PTR_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_TREE_PTR, name)
-
-/* Free up memory allocated by the virtual array, but do not free any of the
- elements involved. */
-#define VARRAY_FREE(vp) \
- do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0)
-
-/* Grow/shrink the virtual array VA to N elements. */
-extern varray_type varray_grow (varray_type, size_t);
-
-#define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
-
-#define VARRAY_SIZE(VA) ((VA)->num_elements)
-
-#define VARRAY_ACTIVE_SIZE(VA) ((VA)->elements_used)
-#define VARRAY_POP_ALL(VA) ((VA)->elements_used = 0)
-
-#define VARRAY_CLEAR(VA) varray_clear(VA)
-
-extern void varray_clear (varray_type);
-extern void dump_varray_statistics (void);
-
-/* Check for VARRAY_xxx macros being in bound. */
-#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
-extern void varray_check_failed (varray_type, size_t, const char *, int,
- const char *) ATTRIBUTE_NORETURN;
-extern void varray_underflow (varray_type, const char *, int, const char *)
- ATTRIBUTE_NORETURN;
-#define VARRAY_CHECK(VA, N, T) __extension__ \
-(*({ varray_type const _va = (VA); \
- const size_t _n = (N); \
- if (_n >= _va->num_elements) \
- varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \
- &_va->data.T[_n]; }))
-
-#define VARRAY_POP(VA) do { \
- varray_type const _va = (VA); \
- if (_va->elements_used == 0) \
- varray_underflow (_va, __FILE__, __LINE__, __FUNCTION__); \
- else \
- _va->elements_used--; \
-} while (0)
-
-#else
-#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
-/* Pop the top element of VA. */
-#define VARRAY_POP(VA) do { ((VA)->elements_used--); } while (0)
-#endif
-
-/* Push X onto VA. T is the name of the field in varray_data
- corresponding to the type of X. */
-#define VARRAY_PUSH(VA, T, X) \
- do \
- { \
- if ((VA)->elements_used >= (VA)->num_elements) \
- VARRAY_GROW ((VA), 2 * (VA)->num_elements); \
- (VA)->data.T[(VA)->elements_used++] = (X); \
- } \
- while (0)
-
-#define VARRAY_CHAR(VA, N) VARRAY_CHECK (VA, N, vdt_c)
-#define VARRAY_UCHAR(VA, N) VARRAY_CHECK (VA, N, vdt_uc)
-#define VARRAY_SHORT(VA, N) VARRAY_CHECK (VA, N, vdt_s)
-#define VARRAY_USHORT(VA, N) VARRAY_CHECK (VA, N, vdt_us)
-#define VARRAY_INT(VA, N) VARRAY_CHECK (VA, N, vdt_i)
-#define VARRAY_UINT(VA, N) VARRAY_CHECK (VA, N, vdt_u)
-#define VARRAY_LONG(VA, N) VARRAY_CHECK (VA, N, vdt_l)
-#define VARRAY_ULONG(VA, N) VARRAY_CHECK (VA, N, vdt_ul)
-#define VARRAY_WIDE_INT(VA, N) VARRAY_CHECK (VA, N, vdt_hint)
-#define VARRAY_UWIDE_INT(VA, N) VARRAY_CHECK (VA, N, vdt_uhint)
-#define VARRAY_GENERIC_PTR(VA,N) VARRAY_CHECK (VA, N, vdt_generic)
-#define VARRAY_GENERIC_PTR_NOGC(VA,N) VARRAY_CHECK (VA, N, vdt_generic_nogc)
-#define VARRAY_CHAR_PTR(VA,N) VARRAY_CHECK (VA, N, vdt_cptr)
-#define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, vdt_rtx)
-#define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, vdt_rtvec)
-#define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, vdt_tree)
-#define VARRAY_BITMAP(VA, N) VARRAY_CHECK (VA, N, vdt_bitmap)
-#define VARRAY_REG(VA, N) VARRAY_CHECK (VA, N, vdt_reg)
-#define VARRAY_BB(VA, N) VARRAY_CHECK (VA, N, vdt_bb)
-#define VARRAY_ELT_LIST(VA, N) VARRAY_CHECK (VA, N, vdt_te)
-#define VARRAY_EDGE(VA, N) VARRAY_CHECK (VA, N, vdt_e)
-#define VARRAY_TREE_PTR(VA, N) VARRAY_CHECK (VA, N, vdt_tp)
-
-/* Push a new element on the end of VA, extending it if necessary. */
-#define VARRAY_PUSH_CHAR(VA, X) VARRAY_PUSH (VA, vdt_c, X)
-#define VARRAY_PUSH_UCHAR(VA, X) VARRAY_PUSH (VA, vdt_uc, X)
-#define VARRAY_PUSH_SHORT(VA, X) VARRAY_PUSH (VA, vdt_s, X)
-#define VARRAY_PUSH_USHORT(VA, X) VARRAY_PUSH (VA, vdt_us, X)
-#define VARRAY_PUSH_INT(VA, X) VARRAY_PUSH (VA, vdt_i, X)
-#define VARRAY_PUSH_UINT(VA, X) VARRAY_PUSH (VA, vdt_u, X)
-#define VARRAY_PUSH_LONG(VA, X) VARRAY_PUSH (VA, vdt_l, X)
-#define VARRAY_PUSH_ULONG(VA, X) VARRAY_PUSH (VA, vdt_ul, X)
-#define VARRAY_PUSH_WIDE_INT(VA, X) VARRAY_PUSH (VA, vdt_hint, X)
-#define VARRAY_PUSH_UWIDE_INT(VA, X) VARRAY_PUSH (VA, vdt_uhint, X)
-#define VARRAY_PUSH_GENERIC_PTR(VA, X) VARRAY_PUSH (VA, vdt_generic, X)
-#define VARRAY_PUSH_GENERIC_PTR_NOGC(VA, X) VARRAY_PUSH (VA, vdt_generic_nogc, X)
-#define VARRAY_PUSH_CHAR_PTR(VA, X) VARRAY_PUSH (VA, vdt_cptr, X)
-#define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, vdt_rtx, X)
-#define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, vdt_rtvec, X)
-#define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, vdt_tree, X)
-#define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, vdt_bitmap, X)
-#define VARRAY_PUSH_REG(VA, X) VARRAY_PUSH (VA, vdt_reg, X)
-#define VARRAY_PUSH_BB(VA, X) VARRAY_PUSH (VA, vdt_bb, X)
-#define VARRAY_PUSH_EDGE(VA, X) VARRAY_PUSH (VA, vdt_e, X)
-#define VARRAY_PUSH_TREE_PTR(VA, X) VARRAY_PUSH (VA, vdt_tp, X)
-
-/* Return the last element of VA. */
-#define VARRAY_TOP(VA, T) VARRAY_CHECK(VA, (VA)->elements_used - 1, T)
-
-#define VARRAY_TOP_CHAR(VA) VARRAY_TOP (VA, vdt_c)
-#define VARRAY_TOP_UCHAR(VA) VARRAY_TOP (VA, vdt_uc)
-#define VARRAY_TOP_SHORT(VA) VARRAY_TOP (VA, vdt_s)
-#define VARRAY_TOP_USHORT(VA) VARRAY_TOP (VA, vdt_us)
-#define VARRAY_TOP_INT(VA) VARRAY_TOP (VA, vdt_i)
-#define VARRAY_TOP_UINT(VA) VARRAY_TOP (VA, vdt_u)
-#define VARRAY_TOP_LONG(VA) VARRAY_TOP (VA, vdt_l)
-#define VARRAY_TOP_ULONG(VA) VARRAY_TOP (VA, vdt_ul)
-#define VARRAY_TOP_WIDE_INT(VA) VARRAY_TOP (VA, vdt_hint)
-#define VARRAY_TOP_UWIDE_INT(VA) VARRAY_TOP (VA, vdt_uhint)
-#define VARRAY_TOP_GENERIC_PTR(VA) VARRAY_TOP (VA, vdt_generic)
-#define VARRAY_TOP_GENERIC_PTR_NOGC(VA) VARRAY_TOP (VA, vdt_generic_nogc)
-#define VARRAY_TOP_CHAR_PTR(VA) VARRAY_TOP (VA, vdt_cptr)
-#define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, vdt_rtx)
-#define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, vdt_rtvec)
-#define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, vdt_tree)
-#define VARRAY_TOP_BITMAP(VA) VARRAY_TOP (VA, vdt_bitmap)
-#define VARRAY_TOP_REG(VA) VARRAY_TOP (VA, vdt_reg)
-#define VARRAY_TOP_BB(VA) VARRAY_TOP (VA, vdt_bb)
-#define VARRAY_TOP_EDGE(VA) VARRAY_TOP (VA, vdt_e)
-#define VARRAY_TOP_TREE_PTR(VA) VARRAY_TOP (VA, vdt_tp)
-
-#endif /* ! GCC_VARRAY_H */
projects / thirdparty / gcc.git / commitdiff
