Skip to content

R
riscv-gcc-1
Commit b6feb796 by Steven Bosscher
Options

sdbout.c: Include vec.h, do not include varray.h. 

	* 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.

From-SVN: r158939
parent 05575e07
Showing with 32 additions and 610 deletions
gcc/ChangeLog
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
......
gcc/Makefile.in
......@@ -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 \
......
gcc/gengtype.c
......@@ -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",
......
gcc/sdbout.c
......@@ -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. */
......
gcc/toplev.c
......@@ -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 ();
......
gcc/varray.c deleted 100644 → 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
}
gcc/varray.h deleted 100644 → 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 */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment