OSDN Git Service

* sdbout.c: Include vec.h, do not include varray.h.
authorsteven <steven@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 30 Apr 2010 14:58:54 +0000 (14:58 +0000)
committersteven <steven@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 30 Apr 2010 14:58:54 +0000 (14:58 +0000)
(deferred_global_decls, sdbout_global_decl,
sdbout_finish, sdbout_init): Use VEC instead of VARRAY.
* toplev.c: Do not include varray.h.
(dump_memory_report): Do not dump VARRAY statistics.
* gengtype.c (open_base_file): Ignore varray.h.
* Makefile.in: Update for abovementioned changes.
Remove all traces of varray.c and varray.h.
* varray.c: Remove file.
* varray.h: Remove file.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158939 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/Makefile.in
gcc/gengtype.c
gcc/sdbout.c
gcc/toplev.c
gcc/varray.c [deleted file]
gcc/varray.h [deleted file]

index a5f8d09..adf9734 100644 (file)
@@ -1,3 +1,16 @@
+2010-04-30  Steven Bosscher  <steven@gcc.gnu.org>
+
+       * sdbout.c: Include vec.h, do not include varray.h.
+       (deferred_global_decls, sdbout_global_decl,
+       sdbout_finish, sdbout_init): Use VEC instead of VARRAY.
+       * toplev.c: Do not include varray.h.
+       (dump_memory_report): Do not dump VARRAY statistics.
+       * gengtype.c (open_base_file): Ignore varray.h.
+       * Makefile.in: Update for abovementioned changes.
+       Remove all traces of varray.c and varray.h.
+       * varray.c: Remove file.
+       * varray.h: Remove file.
+
 2010-04-30  Jan Hubicka  <jh@suse.cz>
 
        * lto-cgraph.c (lto_output_varpool_node): Always output constant pool
index 2ff69ad..48f2c61 100644 (file)
@@ -876,7 +876,7 @@ TREE_H = tree.h all-tree.def tree.def c-common.def $(lang_tree_files) \
           $(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 \
@@ -892,7 +892,7 @@ FLAGS_H = flags.h coretypes.h options.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) \
@@ -911,7 +911,7 @@ DDG_H = ddg.h sbitmap.h $(DF_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)
@@ -944,7 +944,6 @@ C_PRETTY_PRINT_H = c-pretty-print.h $(PRETTY_PRINT_H) $(C_COMMON_H) $(TREE_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
@@ -1403,7 +1402,6 @@ OBJS-common = \
        value-prof.o \
        var-tracking.o \
        varasm.o \
-       varray.o \
        vec.o \
        version.o \
        vmsdbgout.o \
@@ -2180,7 +2178,7 @@ endif
        -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 \
@@ -2285,7 +2283,7 @@ stor-layout.o : stor-layout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_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
@@ -2560,7 +2558,7 @@ tree-browser.o : tree-browser.c tree-browser.def $(CONFIG_H) $(SYSTEM_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)
@@ -2710,7 +2708,7 @@ diagnostic.o : diagnostic.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_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
@@ -2736,7 +2734,7 @@ toplev.o : toplev.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_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)
@@ -2763,7 +2761,7 @@ host-default.o : host-default.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
 
 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)
@@ -2840,7 +2838,7 @@ debug.o : debug.c debug.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_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) \
@@ -3147,8 +3145,6 @@ reginfo.o : reginfo.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_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) \
@@ -3583,7 +3579,7 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.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 \
index 27d5be2..66b4105 100644 (file)
@@ -1564,7 +1564,7 @@ open_base_files (void)
   {
     /* The order of files here matters very much.  */
     static const char *const ifiles [] = {
-      "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
+      "config.h", "system.h", "coretypes.h", "tm.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",
index f4541ea..87a00b4 100644 (file)
@@ -48,7 +48,7 @@ AT&T C compiler.  From the example below I would conclude the following:
 #include "debug.h"
 #include "tree.h"
 #include "ggc.h"
-#include "varray.h"
+#include "vec.h"
 
 static GTY(()) tree anonymous_types;
 
@@ -58,7 +58,7 @@ static GTY(()) int unnamed_struct_number;
 
 /* Declarations whose debug info was deferred till end of compilation.  */
 
-static GTY(()) varray_type deferred_global_decls;
+static GTY(()) VEC(tree,gc) *deferred_global_decls;
 
 /* The C front end may call sdbout_symbol before sdbout_init runs.
    We save all such decls in this list and output them when we get
@@ -1464,7 +1464,7 @@ sdbout_global_decl (tree decl)
       if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
        sdbout_symbol (decl, 0);
       else
-       VARRAY_PUSH_TREE (deferred_global_decls, decl);
+       VEC_safe_push (tree, gc, deferred_global_decls, decl);
 
       /* Output COFF information for non-global file-scope initialized
         variables.  */
@@ -1480,9 +1480,10 @@ static void
 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED)
 {
   size_t i;
+  tree decl;
 
-  for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_global_decls); i++)
-    sdbout_symbol (VARRAY_TREE (deferred_global_decls, i), 0);
+  for (i = 0; VEC_iterate (tree, deferred_global_decls, i, decl); i++)
+    sdbout_symbol (decl, 0);
 }
 
 /* Describe the beginning of an internal block within a function.
@@ -1689,7 +1690,7 @@ sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED)
   current_file->name = input_file_name;
 #endif
 
-  VARRAY_TREE_INIT (deferred_global_decls, 12, "deferred_global_decls");
+  deferred_global_decls = VEC_alloc (tree, gc, 12);
 
   /* Emit debug information which was queued by sdbout_symbol before
      we got here.  */
index 50b79a7..b62380b 100644 (file)
@@ -86,7 +86,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "gimple.h"
 #include "tree-ssa-alias.h"
 #include "plugin.h"
-#include "varray.h"
 
 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
 #include "dwarf2out.h"
@@ -2348,7 +2347,6 @@ dump_memory_report (bool final)
   dump_tree_statistics ();
   dump_gimple_statistics ();
   dump_rtx_statistics ();
-  dump_varray_statistics ();
   dump_alloc_pool_statistics ();
   dump_bitmap_statistics ();
   dump_vec_loc_statistics ();
diff --git a/gcc/varray.c b/gcc/varray.c
deleted file mode 100644 (file)
index 91e5b5d..0000000
+++ /dev/null
@@ -1,263 +0,0 @@
-/* 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
-}
diff --git a/gcc/varray.h b/gcc/varray.h
deleted file mode 100644 (file)
index fbccde3..0000000
+++ /dev/null
@@ -1,323 +0,0 @@
-/* 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 */