This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFC] Move hash-table.h and related files to libiberty


On September 21, 2019 11:12:38 AM GMT+02:00, Christian Biesinger via gcc-patches <gcc-patches@gcc.gnu.org> wrote:
>Hello,
>
>I would like to move hash-table.h, hash-map.h and related files
>to libiberty, so that GDB can make use of it.
>
>I see that gcc already has a C++ file in include/ (unique-ptr.h),
>which I understand is libiberty.
>
>However, this patch is not complete yet (for a start, it doesn't
>compile). Before I go further down this road, is this acceptable
>in principle to the gcc/libiberty maintainers?
>
>(the bulk of the patch is including vec.h in a lot of files,
>because hash-table.h previously included it. It doesn't
>actually use it, and I didn't think it was necessary to
>move that to libiberty as well, so I removed that include
>and instead am adding it to all the files that now don't
>compile.)

The bulk seems to be hash_table to hash_table_ggc renaming. Can you explain? Also we can then rename create_ggc back to create? 

Richard. 

>Thanks!
>Christian
>
>Index: Makefile.in
>===================================================================
>--- Makefile.in	(revision 275695)
>+++ Makefile.in	(working copy)
>@@ -1490,7 +1490,6 @@
> 	spellcheck-tree.o \
> 	sreal.o \
> 	stack-ptr-mod.o \
>-	statistics.o \
> 	stmt.o \
> 	stor-layout.o \
> 	store-motion.o \
>Index: bitmap.c
>===================================================================
>--- bitmap.c	(revision 275695)
>+++ bitmap.c	(working copy)
>@@ -22,6 +22,7 @@
> #include "coretypes.h"
> #include "bitmap.h"
> #include "selftest.h"
>+#include "vec.h"
> 
> /* Memory allocation statistics purpose instance.  */
> mem_alloc_description<bitmap_usage> bitmap_mem_desc;
>Index: cfgloop.c
>===================================================================
>--- cfgloop.c	(revision 275695)
>+++ cfgloop.c	(working copy)
>@@ -1135,7 +1135,7 @@
> 
>   gcc_assert (current_loops->exits == NULL);
>   current_loops->exits
>-    = hash_table<loop_exit_hasher>::create_ggc (2 * number_of_loops
>(cfun));
>+    = hash_table_ggc<loop_exit_hasher>::create_ggc (2 *
>number_of_loops (cfun));
> 
>   FOR_EACH_BB_FN (bb, cfun)
>     {
>Index: cgraph.c
>===================================================================
>--- cgraph.c	(revision 275695)
>+++ cgraph.c	(working copy)
>@@ -183,7 +183,7 @@
>   version_info_node->this_node = this;
> 
>   if (cgraph_fnver_htab == NULL)
>-    cgraph_fnver_htab =
>hash_table<function_version_hasher>::create_ggc (2);
>+    cgraph_fnver_htab =
>hash_table_ggc<function_version_hasher>::create_ggc (2);
> 
>   *cgraph_fnver_htab->find_slot (version_info_node, INSERT)
>     = version_info_node;
>@@ -760,7 +760,7 @@
> 
>   if (n > 100)
>     {
>-      call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc
>(120);
>+      call_site_hash = hash_table_ggc<cgraph_edge_hasher>::create_ggc
>(120);
>       for (e2 = callees; e2; e2 = e2->next_callee)
> 	cgraph_add_edge_to_call_site_hash (e2);
>       for (e2 = indirect_calls; e2; e2 = e2->next_callee)
>Index: common/common-target.h
>===================================================================
>--- common/common-target.h	(revision 275695)
>+++ common/common-target.h	(working copy)
>@@ -22,6 +22,7 @@
> #ifndef GCC_COMMON_TARGET_H
> #define GCC_COMMON_TARGET_H
> 
>+#include "vec.h"
> 
> /* Sets of optimization levels at which an option may be enabled by
>    default_options_optimization.  */
>Index: common/common-targhooks.h
>===================================================================
>--- common/common-targhooks.h	(revision 275695)
>+++ common/common-targhooks.h	(working copy)
>@@ -20,6 +20,8 @@
> #ifndef GCC_COMMON_TARGHOOKS_H
> #define GCC_COMMON_TARGHOOKS_H
> 
>+#include "vec.h"
>+
>extern enum unwind_info_type default_except_unwind_info (struct
>gcc_options *);
>extern enum unwind_info_type dwarf2_except_unwind_info (struct
>gcc_options *);
>extern enum unwind_info_type sjlj_except_unwind_info (struct
>gcc_options *);
>Index: config/darwin.c
>===================================================================
>--- config/darwin.c	(revision 275695)
>+++ config/darwin.c	(working copy)
>@@ -572,7 +572,7 @@
>sprintf (buffer, "&%s%c%s%s%s%s", quote, L_or_l, prefix, name, suffix,
>quote);
> 
>   if (!machopic_indirections)
>-    machopic_indirections = hash_table<indirection_hasher>::create_ggc
>(37);
>+    machopic_indirections =
>hash_table_ggc<indirection_hasher>::create_ggc (37);
> 
>   machopic_indirection **slot
>     = machopic_indirections->find_slot_with_hash (buffer,
>@@ -3454,7 +3454,7 @@
>   rest_of_decl_compilation (cfstring_class_reference, 0, 0);
> 
>/* Initialize the hash table used to hold the constant CFString
>objects.  */
>-  cfstring_htab = hash_table<cfstring_hasher>::create_ggc (31);
>+  cfstring_htab = hash_table_ggc<cfstring_hasher>::create_ggc (31);
> 
>   return cfstring_type_node;
> }
>Index: config/i386/i386.c
>===================================================================
>--- config/i386/i386.c	(revision 275695)
>+++ config/i386/i386.c	(working copy)
>@@ -95,6 +95,7 @@
> #include "i386-builtins.h"
> #include "i386-expand.h"
> #include "i386-features.h"
>+#include "hash-table-ggc.h"
> 
> /* This file should be included last.  */
> #include "target-def.h"
>@@ -11048,7 +11049,7 @@
>   rtx rtl;
> 
>   if (!dllimport_map)
>-    dllimport_map = hash_table<dllimport_hasher>::create_ggc (512);
>+    dllimport_map = hash_table_ggc<dllimport_hasher>::create_ggc
>(512);
> 
>   in.hash = htab_hash_pointer (decl);
>   in.base.from = decl;
>Index: cp/constexpr.c
>===================================================================
>--- cp/constexpr.c	(revision 275695)
>+++ cp/constexpr.c	(working copy)
>@@ -895,7 +895,7 @@
>   /* Create the constexpr function table if necessary.  */
>   if (constexpr_fundef_table == NULL)
>     constexpr_fundef_table
>-      = hash_table<constexpr_fundef_hasher>::create_ggc (101);
>+      = hash_table_ggc<constexpr_fundef_hasher>::create_ggc (101);
> 
>   entry.decl = fun;
>   tree saved_fn = current_function_decl;
>@@ -1081,7 +1081,7 @@
> maybe_initialize_constexpr_call_table (void)
> {
>   if (constexpr_call_table == NULL)
>-    constexpr_call_table =
>hash_table<constexpr_call_hasher>::create_ggc (101);
>+    constexpr_call_table =
>hash_table_ggc<constexpr_call_hasher>::create_ggc (101);
> }
> 
>/* During constexpr CALL_EXPR evaluation, to avoid issues with sharing
>when
>Index: cp/decl.c
>===================================================================
>--- cp/decl.c	(revision 275695)
>+++ cp/decl.c	(working copy)
>@@ -3070,7 +3070,7 @@
>     }
> 
>   if (!named_labels)
>-    named_labels = hash_table<named_label_hash>::create_ggc (13);
>+    named_labels = hash_table_ggc<named_label_hash>::create_ggc (13);
> 
>   hashval_t hash = IDENTIFIER_HASH_VALUE (id);
>   named_label_entry **slot
>@@ -3754,7 +3754,7 @@
>   hashval_t hash;
> 
>   if (typename_htab == NULL)
>-    typename_htab = hash_table<typename_hasher>::create_ggc (61);
>+    typename_htab = hash_table_ggc<typename_hasher>::create_ggc (61);
> 
>   ti.scope = FROB_CONTEXT (context);
>   ti.name = name;
>Index: cp/decl2.c
>===================================================================
>--- cp/decl2.c	(revision 275695)
>+++ cp/decl2.c	(working copy)
>@@ -4612,7 +4612,7 @@
> record_mangling (tree decl, bool need_warning)
> {
>   if (!mangled_decls)
>-    mangled_decls = hash_table<mangled_decl_hash>::create_ggc (499);
>+    mangled_decls = hash_table_ggc<mangled_decl_hash>::create_ggc
>(499);
> 
>   gcc_checking_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
>   tree id = DECL_ASSEMBLER_NAME_RAW (decl);
>Index: cp/lex.c
>===================================================================
>--- cp/lex.c	(revision 275695)
>+++ cp/lex.c	(working copy)
>@@ -625,7 +625,7 @@
>     return error_mark_node;
> 
>   if (conv_type_names == NULL)
>-    conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
>+    conv_type_names = hash_table_ggc<conv_type_hasher>::create_ggc
>(31);
> 
>   tree *slot = conv_type_names->find_slot_with_hash
>     (type, (hashval_t) TYPE_UID (type), INSERT);
>@@ -703,7 +703,7 @@
> 
>   if (sel == lds_ns)
>     /* Who'd create a namespace, only to put nothing in it?  */
>-    ld->u.ns.bindings = hash_table<named_decl_hash>::create_ggc (499);
>+    ld->u.ns.bindings = hash_table_ggc<named_decl_hash>::create_ggc
>(499);
> 
>   if (GATHER_STATISTICS)
>     {
>Index: cp/name-lookup.c
>===================================================================
>--- cp/name-lookup.c	(revision 275695)
>+++ cp/name-lookup.c	(working copy)
>@@ -2522,7 +2522,7 @@
>     return;
> 
>   if (!extern_c_decls)
>-    extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
>+    extern_c_decls = hash_table_ggc<named_decl_hash>::create_ggc
>(127);
> 
>   tree *slot = extern_c_decls
>     ->find_slot_with_hash (DECL_NAME (decl),
>@@ -2907,7 +2907,7 @@
> 
> 	    if (cp_function_chain->extern_decl_map == NULL)
> 	      cp_function_chain->extern_decl_map
>-		= hash_table<cxx_int_tree_map_hasher>::create_ggc (20);
>+		= hash_table_ggc<cxx_int_tree_map_hasher>::create_ggc (20);
> 
> 	    h = ggc_alloc<cxx_int_tree_map> ();
> 	    h->uid = DECL_UID (decl);
>Index: cp/pt.c
>===================================================================
>--- cp/pt.c	(revision 275695)
>+++ cp/pt.c	(working copy)
>@@ -28306,11 +28306,11 @@
>   if (!flag_concepts)
>     return;
> 
>-  decl_constraints = hash_table<constr_hasher>::create_ggc(37);
>-  constraint_memos =
>hash_table<constraint_sat_hasher>::create_ggc(37);
>-  concept_memos = hash_table<concept_spec_hasher>::create_ggc(37);
>-  concept_expansions =
>hash_table<concept_spec_hasher>::create_ggc(37);
>-  subsumption_table = hash_table<subsumption_hasher>::create_ggc(37);
>+  decl_constraints = hash_table_ggc<constr_hasher>::create_ggc(37);
>+  constraint_memos =
>hash_table_ggc<constraint_sat_hasher>::create_ggc(37);
>+  concept_memos = hash_table_ggc<concept_spec_hasher>::create_ggc(37);
>+  concept_expansions =
>hash_table_ggc<concept_spec_hasher>::create_ggc(37);
>+  subsumption_table =
>hash_table_ggc<subsumption_hasher>::create_ggc(37);
> }
> 
>/* __integer_pack(N) in a pack expansion expands to a sequence of
>numbers from
>@@ -28335,8 +28335,8 @@
> init_template_processing (void)
> {
>   /* FIXME: enable sanitization (PR87847) */
>-  decl_specializations = hash_table<spec_hasher>::create_ggc (37,
>false);
>-  type_specializations = hash_table<spec_hasher>::create_ggc (37,
>false);
>+  decl_specializations = hash_table_ggc<spec_hasher>::create_ggc (37,
>false);
>+  type_specializations = hash_table_ggc<spec_hasher>::create_ggc (37,
>false);
> 
>   if (cxx_dialect >= cxx11)
>     declare_integer_pack ();
>Index: cp/tree.c
>===================================================================
>--- cp/tree.c	(revision 275695)
>+++ cp/tree.c	(working copy)
>@@ -1011,7 +1011,7 @@
>       hashval_t hash;
> 
>       if (cplus_array_htab == NULL)
>-	cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61);
>+	cplus_array_htab = hash_table_ggc<cplus_array_hasher>::create_ggc
>(61);
>       
>       hash = TYPE_UID (elt_type);
>       if (index_type)
>@@ -4982,7 +4982,7 @@
> void
> init_tree (void)
> {
>-  list_hash_table = hash_table<list_hasher>::create_ggc (61);
>+  list_hash_table = hash_table_ggc<list_hasher>::create_ggc (61);
>   register_scoped_attributes (std_attribute_table, NULL);
> }
> 
>Index: cp/typeck2.c
>===================================================================
>--- cp/typeck2.c	(revision 275695)
>+++ cp/typeck2.c	(working copy)
>@@ -277,7 +277,7 @@
> 
>       if (!abstract_pending_vars)
> 	abstract_pending_vars
>-	  = hash_table<abstract_type_hasher>::create_ggc (31);
>+	  = hash_table_ggc<abstract_type_hasher>::create_ggc (31);
> 
>       pending_abstract_type **slot
>  	= abstract_pending_vars->find_slot_with_hash (type, TYPE_UID (type),
>Index: dbgcnt.c
>===================================================================
>--- dbgcnt.c	(revision 275695)
>+++ dbgcnt.c	(working copy)
>@@ -24,6 +24,7 @@
> #include "coretypes.h"
> #include "diagnostic-core.h"
> #include "dumpfile.h"
>+#include "vec.h"
> 
> #include "dbgcnt.h"
> 
>Index: diagnostic-show-locus.c
>===================================================================
>--- diagnostic-show-locus.c	(revision 275695)
>+++ diagnostic-show-locus.c	(working copy)
>@@ -30,6 +30,7 @@
> #include "gcc-rich-location.h"
> #include "selftest.h"
> #include "selftest-diagnostic.h"
>+#include "vec.h"
> 
> #ifdef HAVE_TERMIOS_H
> # include <termios.h>
>Index: dwarf2out.c
>===================================================================
>--- dwarf2out.c	(revision 275695)
>+++ dwarf2out.c	(working copy)
>@@ -4651,7 +4651,7 @@
> find_AT_string (const char *str, enum insert_option insert = INSERT)
> {
>   if (! debug_str_hash)
>-    debug_str_hash = hash_table<indirect_string_hasher>::create_ggc
>(10);
>+    debug_str_hash =
>hash_table_ggc<indirect_string_hasher>::create_ggc (10);
> 
>   return find_AT_string_in_table (str, debug_str_hash, insert);
> }
>@@ -5023,7 +5023,7 @@
> 
>   gcc_assert (dwarf_split_debug_info);
>   if (! addr_index_table)
>-    addr_index_table = hash_table<addr_hasher>::create_ggc (10);
>+    addr_index_table = hash_table_ggc<addr_hasher>::create_ggc (10);
>   init_addr_table_entry (&finder, kind, addr);
>addr_table_entry **slot = addr_index_table->find_slot (&finder,
>INSERT);
> 
>@@ -11170,7 +11170,7 @@
> 
>   if (! skeleton_debug_str_hash)
>     skeleton_debug_str_hash
>-      = hash_table<indirect_string_hasher>::create_ggc (10);
>+      = hash_table_ggc<indirect_string_hasher>::create_ggc (10);
> 
>   node = find_AT_string_in_table (str, skeleton_debug_str_hash);
>   find_string_form (node);
>@@ -12145,7 +12145,7 @@
>     case DW_FORM_line_strp:
>       if (!debug_line_str_hash)
> 	debug_line_str_hash
>-	  = hash_table<indirect_string_hasher>::create_ggc (10);
>+	  = hash_table_ggc<indirect_string_hasher>::create_ggc (10);
> 
>       struct indirect_string_node *node;
>       node = find_AT_string_in_table (str, debug_line_str_hash);
>@@ -23765,7 +23765,7 @@
> 	}
> 
>       if (common_block_die_table == NULL)
>-	common_block_die_table = hash_table<block_die_hasher>::create_ggc
>(10);
>+	common_block_die_table = hash_table_ggc<block_die_hasher>::create_ggc
>(10);
> 
>       com_die_arg.decl_id = DECL_UID (com_decl);
>       com_die_arg.die_parent = context_die;
>@@ -27666,7 +27666,7 @@
> 
>   if (!inline_entry_data_table)
>     inline_entry_data_table
>-      = hash_table<inline_entry_data_hasher>::create_ggc (10);
>+      = hash_table_ggc<inline_entry_data_hasher>::create_ggc (10);
> 
> 
>   inline_entry_data **iedp
>@@ -28836,17 +28836,17 @@
> dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
> {
>   /* Allocate the file_table.  */
>-  file_table = hash_table<dwarf_file_hasher>::create_ggc (50);
>+  file_table = hash_table_ggc<dwarf_file_hasher>::create_ggc (50);
> 
> #ifndef DWARF2_LINENO_DEBUGGING_INFO
>   /* Allocate the decl_die_table.  */
>-  decl_die_table = hash_table<decl_die_hasher>::create_ggc (10);
>+  decl_die_table = hash_table_ggc<decl_die_hasher>::create_ggc (10);
> 
>   /* Allocate the decl_loc_table.  */
>-  decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10);
>+  decl_loc_table = hash_table_ggc<decl_loc_hasher>::create_ggc (10);
> 
>   /* Allocate the cached_dw_loc_list_table.  */
>-  cached_dw_loc_list_table =
>hash_table<dw_loc_list_hasher>::create_ggc (10);
>+  cached_dw_loc_list_table =
>hash_table_ggc<dw_loc_list_hasher>::create_ggc (10);
> 
>   /* Allocate the initial hunk of the abbrev_die_table.  */
>   vec_alloc (abbrev_die_table, 256);
>@@ -32002,7 +32002,7 @@
> 	  {
> 	    if (!variable_value_hash)
> 	      variable_value_hash
>-		= hash_table<variable_value_hasher>::create_ggc (10);
>+		= hash_table_ggc<variable_value_hasher>::create_ggc (10);
> 
> 	    tree fndecl = DECL_CONTEXT (decl);
> 	    struct variable_value_struct *node;
>@@ -32098,7 +32098,7 @@
> 
> 	  if (! debug_line_str_hash)
> 	    debug_line_str_hash
>-	      = hash_table<indirect_string_hasher>::create_ggc (10);
>+	      = hash_table_ggc<indirect_string_hasher>::create_ggc (10);
> 
> 	  struct indirect_string_node *node
> 	    = find_AT_string_in_table (AT_string (a), debug_line_str_hash);
>Index: edit-context.c
>===================================================================
>--- edit-context.c	(revision 275695)
>+++ edit-context.c	(working copy)
>@@ -25,6 +25,7 @@
> #include "pretty-print.h"
> #include "diagnostic-color.h"
> #include "selftest.h"
>+#include "vec.h"
> 
> /* This file implements a way to track the effect of fix-its,
>    via a class edit_context; the other classes are support classes for
>Index: emit-rtl.c
>===================================================================
>--- emit-rtl.c	(revision 275695)
>+++ emit-rtl.c	(working copy)
>@@ -6218,19 +6218,19 @@
> 
>   /* Initialize the CONST_INT, CONST_WIDE_INT, CONST_DOUBLE,
>      CONST_FIXED, and memory attribute hash tables.  */
>-  const_int_htab = hash_table<const_int_hasher>::create_ggc (37);
>+  const_int_htab = hash_table_ggc<const_int_hasher>::create_ggc (37);
> 
> #if TARGET_SUPPORTS_WIDE_INT
>-  const_wide_int_htab = hash_table<const_wide_int_hasher>::create_ggc
>(37);
>+  const_wide_int_htab =
>hash_table_ggc<const_wide_int_hasher>::create_ggc (37);
> #endif
>-  const_double_htab = hash_table<const_double_hasher>::create_ggc
>(37);
>+  const_double_htab = hash_table_ggc<const_double_hasher>::create_ggc
>(37);
> 
>   if (NUM_POLY_INT_COEFFS > 1)
>-    const_poly_int_htab =
>hash_table<const_poly_int_hasher>::create_ggc (37);
>+    const_poly_int_htab =
>hash_table_ggc<const_poly_int_hasher>::create_ggc (37);
> 
>-  const_fixed_htab = hash_table<const_fixed_hasher>::create_ggc (37);
>+  const_fixed_htab = hash_table_ggc<const_fixed_hasher>::create_ggc
>(37);
> 
>-  reg_attrs_htab = hash_table<reg_attr_hasher>::create_ggc (37);
>+  reg_attrs_htab = hash_table_ggc<reg_attr_hasher>::create_ggc (37);
> 
> #ifdef INIT_EXPANDERS
>/* This is to initialize {init|mark|free}_machine_status before the
>first
>Index: fibonacci_heap.h
>===================================================================
>--- fibonacci_heap.h	(revision 275695)
>+++ fibonacci_heap.h	(working copy)
>@@ -40,6 +40,8 @@
> #ifndef GCC_FIBONACCI_HEAP_H
> #define GCC_FIBONACCI_HEAP_H
> 
>+#include "vec.h"
>+
> /* Forward definition.  */
> 
> template<class K, class V>
>Index: fortran/trans-decl.c
>===================================================================
>--- fortran/trans-decl.c	(revision 275695)
>+++ fortran/trans-decl.c	(working copy)
>@@ -5095,7 +5095,7 @@
> gfc_find_module (const char *name)
> {
>   if (! module_htab)
>-    module_htab = hash_table<module_hasher>::create_ggc (10);
>+    module_htab = hash_table_ggc<module_hasher>::create_ggc (10);
> 
>   module_htab_entry **slot
>= module_htab->find_slot_with_hash (name, htab_hash_string (name),
>INSERT);
>@@ -5104,7 +5104,7 @@
>    module_htab_entry *entry = ggc_cleared_alloc<module_htab_entry> ();
> 
>       entry->name = gfc_get_string ("%s", name);
>-      entry->decls = hash_table<module_decl_hasher>::create_ggc (10);
>+      entry->decls = hash_table_ggc<module_decl_hasher>::create_ggc
>(10);
>       *slot = entry;
>     }
>   return *slot;
>Index: function.c
>===================================================================
>--- function.c	(revision 275695)
>+++ function.c	(working copy)
>@@ -1237,7 +1237,7 @@
> 
>   /* Set up the table to map addresses to temp slots.  */
>   if (! temp_slot_address_table)
>-    temp_slot_address_table =
>hash_table<temp_address_hasher>::create_ggc (32);
>+    temp_slot_address_table =
>hash_table_ggc<temp_address_hasher>::create_ggc (32);
>   else
>     temp_slot_address_table->empty ();
> }
>@@ -5607,7 +5607,7 @@
>   hash_table<insn_cache_hasher> *hash = *hashp;
> 
>   if (hash == NULL)
>-    *hashp = hash = hash_table<insn_cache_hasher>::create_ggc (17);
>+    *hashp = hash = hash_table_ggc<insn_cache_hasher>::create_ggc
>(17);
> 
>   for (tmp = insns; tmp != end; tmp = NEXT_INSN (tmp))
>     {
>@@ -6285,7 +6285,7 @@
>       e.type = type;
>       if (types_used_by_vars_hash == NULL)
> 	types_used_by_vars_hash
>-	  = hash_table<used_type_hasher>::create_ggc (37);
>+	  = hash_table_ggc<used_type_hasher>::create_ggc (37);
> 
>       slot = types_used_by_vars_hash->find_slot (&e, INSERT);
>       if (*slot == NULL)
>Index: function.h
>===================================================================
>--- function.h	(revision 275695)
>+++ function.h	(working copy)
>@@ -20,6 +20,7 @@
> #ifndef GCC_FUNCTION_H
> #define GCC_FUNCTION_H
> 
>+#include "vec.h"
> 
> /* Stack of pending (incomplete) sequences saved by `start_sequence'.
>    Each element describes one pending sequence.
>Index: genmatch.c
>===================================================================
>--- genmatch.c	(revision 275695)
>+++ genmatch.c	(working copy)
>@@ -29,6 +29,7 @@
> #include "hash-table.h"
> #include "hash-set.h"
> #include "is-a.h"
>+#include "vec.h"
> 
> 
>/* Stubs for GGC referenced through instantiations triggered by
>hash-map.  */
>Index: ggc-common.c
>===================================================================
>--- ggc-common.c	(revision 275695)
>+++ ggc-common.c	(working copy)
>@@ -29,6 +29,7 @@
> #include "params.h"
> #include "hosthooks.h"
> #include "plugin.h"
>+#include "vec.h"
> 
> /* When set, ggc_collect will do collection.  */
> bool ggc_force_collect;
>Index: graphds.h
>===================================================================
>--- graphds.h	(revision 275695)
>+++ graphds.h	(working copy)
>@@ -20,6 +20,8 @@
> #ifndef GCC_GRAPHDS_H
> #define GCC_GRAPHDS_H
> 
>+#include "vec.h"
>+
> /* Structure representing edge of a graph.  */
> 
> struct graph_edge
>Index: hash-map-traits.h
>===================================================================
>--- hash-map-traits.h	(revision 275695)
>+++ hash-map-traits.h	(nonexistent)
>@@ -1,188 +0,0 @@
>-/* A hash map traits.
>-   Copyright (C) 2015-2019 Free Software Foundation, Inc.
>-
>-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 HASH_MAP_TRAITS_H
>-#define HASH_MAP_TRAITS_H
>-
>-/* Bacause mem-stats.h uses default hashmap traits, we have to
>-   put the class to this separate header file.  */
>-
>-#include "hash-traits.h"
>-
>-/* Implement hash_map traits for a key with hash traits H.  Empty and
>-   deleted map entries are represented as empty and deleted keys.  */
>-
>-template <typename H, typename Value>
>-struct simple_hashmap_traits
>-{
>-  typedef typename H::value_type key_type;
>-  static const bool maybe_mx = true;
>-  static inline hashval_t hash (const key_type &);
>-  static inline bool equal_keys (const key_type &, const key_type &);
>-  template <typename T> static inline void remove (T &);
>-  template <typename T> static inline bool is_empty (const T &);
>-  template <typename T> static inline bool is_deleted (const T &);
>-  template <typename T> static inline void mark_empty (T &);
>-  template <typename T> static inline void mark_deleted (T &);
>-};
>-
>-template <typename H, typename Value>
>-inline hashval_t
>-simple_hashmap_traits <H, Value>::hash (const key_type &h)
>-{
>-  return H::hash (h);
>-}
>-
>-template <typename H, typename Value>
>-inline bool
>-simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
>-					      const key_type &k2)
>-{
>-  return H::equal (k1, k2);
>-}
>-
>-template <typename H, typename Value>
>-template <typename T>
>-inline void
>-simple_hashmap_traits <H, Value>::remove (T &entry)
>-{
>-  H::remove (entry.m_key);
>-  entry.m_value.~Value ();
>-}
>-
>-template <typename H, typename Value>
>-template <typename T>
>-inline bool
>-simple_hashmap_traits <H, Value>::is_empty (const T &entry)
>-{
>-  return H::is_empty (entry.m_key);
>-}
>-
>-template <typename H, typename Value>
>-template <typename T>
>-inline bool
>-simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
>-{
>-  return H::is_deleted (entry.m_key);
>-}
>-
>-template <typename H, typename Value>
>-template <typename T>
>-inline void
>-simple_hashmap_traits <H, Value>::mark_empty (T &entry)
>-{
>-  H::mark_empty (entry.m_key);
>-}
>-
>-template <typename H, typename Value>
>-template <typename T>
>-inline void
>-simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
>-{
>-  H::mark_deleted (entry.m_key);
>-}
>-
>-template <typename H, typename Value>
>-struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
>-{
>-  static const bool maybe_mx = false;
>-};
>-
>-/* Implement traits for a hash_map with values of type Value for cases
>-   in which the key cannot represent empty and deleted slots.  Instead
>-   record empty and deleted entries in Value.  Derived classes must
>-   implement the hash and equal_keys functions.  */
>-
>-template <typename Value>
>-struct unbounded_hashmap_traits
>-{
>-  template <typename T> static inline void remove (T &);
>-  template <typename T> static inline bool is_empty (const T &);
>-  template <typename T> static inline bool is_deleted (const T &);
>-  template <typename T> static inline void mark_empty (T &);
>-  template <typename T> static inline void mark_deleted (T &);
>-};
>-
>-template <typename Value>
>-template <typename T>
>-inline void
>-unbounded_hashmap_traits <Value>::remove (T &entry)
>-{
>-  default_hash_traits <Value>::remove (entry.m_value);
>-}
>-
>-template <typename Value>
>-template <typename T>
>-inline bool
>-unbounded_hashmap_traits <Value>::is_empty (const T &entry)
>-{
>-  return default_hash_traits <Value>::is_empty (entry.m_value);
>-}
>-
>-template <typename Value>
>-template <typename T>
>-inline bool
>-unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
>-{
>-  return default_hash_traits <Value>::is_deleted (entry.m_value);
>-}
>-
>-template <typename Value>
>-template <typename T>
>-inline void
>-unbounded_hashmap_traits <Value>::mark_empty (T &entry)
>-{
>-  default_hash_traits <Value>::mark_empty (entry.m_value);
>-}
>-
>-template <typename Value>
>-template <typename T>
>-inline void
>-unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
>-{
>-  default_hash_traits <Value>::mark_deleted (entry.m_value);
>-}
>-
>-/* Implement traits for a hash_map from integer type Key to Value in
>-   cases where Key has no spare values for recording empty and deleted
>-   slots.  */
>-
>-template <typename Key, typename Value>
>-struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
>-{
>-  typedef Key key_type;
>-  static inline hashval_t hash (Key);
>-  static inline bool equal_keys (Key, Key);
>-};
>-
>-template <typename Key, typename Value>
>-inline hashval_t
>-unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
>-{
>-  return k;
>-}
>-
>-template <typename Key, typename Value>
>-inline bool
>-unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
>-{
>-  return k1 == k2;
>-}
>-
>-#endif // HASH_MAP_TRAITS_H
>Index: hash-map.h
>===================================================================
>--- hash-map.h	(revision 275695)
>+++ hash-map.h	(working copy)
>@@ -21,6 +21,8 @@
> #ifndef hash_map_h
> #define hash_map_h
> 
>+#include "hash-table-ggc.h"
>+
> /* Class hash_map is a hash-value based container mapping objects of
>    KeyId type to those of the Value type.
>    Both KeyId and Value may be non-trivial (non-POD) types provided
>Index: hash-table.h
>===================================================================
>--- hash-table.h	(revision 275695)
>+++ hash-table.h	(nonexistent)
>@@ -1,1231 +0,0 @@
>-/* A type-safe hash table template.
>-   Copyright (C) 2012-2019 Free Software Foundation, Inc.
>-   Contributed by Lawrence Crowl <crowl@google.com>
>-
>-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/>.  */
>-
>-
>-/* This file implements a typed hash table.
>-   The implementation borrows from libiberty's htab_t in hashtab.h.
>-
>-
>-   INTRODUCTION TO TYPES
>-
>-   Users of the hash table generally need to be aware of three types.
>-
>-      1. The type being placed into the hash table.  This type is
>called
>-      the value type.
>-
>-      2. The type used to describe how to handle the value type within
>-      the hash table.  This descriptor type provides the hash table
>with
>-      several things.
>-
>-         - A typedef named 'value_type' to the value type (from
>above).
>-	 Provided a suitable Descriptor class it may be a user-defined,
>-	 non-POD type.
>-
>-         - A static member function named 'hash' that takes a
>value_type
>-         (or 'const value_type &') and returns a hashval_t value.
>-
>-         - A typedef named 'compare_type' that is used to test when a
>value
>-	 is found.  This type is the comparison type.  Usually, it will be
>-	 the same as value_type and may be a user-defined, non-POD type.
>-	 If it is not the same type, you must generally explicitly compute
>-	 hash values and pass them to the hash table.
>-
>-         - A static member function named 'equal' that takes a
>value_type
>-         and a compare_type, and returns a bool.  Both arguments can
>be
>-         const references.
>-
>-         - A static function named 'remove' that takes an value_type
>pointer
>-         and frees the memory allocated by it.  This function is used
>when
>-         individual elements of the table need to be disposed of
>(e.g.,
>-         when deleting a hash table, removing elements from the table,
>etc).
>-
>-	 - An optional static function named 'keep_cache_entry'.  This
>-	 function is provided only for garbage-collected elements that
>-	 are not marked by the normal gc mark pass.  It describes what
>-	 what should happen to the element at the end of the gc mark phase.
>-	 The return value should be:
>-	   - 0 if the element should be deleted
>-	   - 1 if the element should be kept and needs to be marked
>-	   - -1 if the element should be kept and is already marked.
>-	 Returning -1 rather than 1 is purely an optimization.
>-
>-      3. The type of the hash table itself.  (More later.)
>-
>-   In very special circumstances, users may need to know about a
>fourth type.
>-
>-      4. The template type used to describe how hash table memory
>-      is allocated.  This type is called the allocator type.  It is
>-      parameterized on the value type.  It provides two functions:
>-
>-         - A static member function named 'data_alloc'.  This function
>-         allocates the data elements in the table.
>-
>-         - A static member function named 'data_free'.  This function
>-         deallocates the data elements in the table.
>-
>-   Hash table are instantiated with two type arguments.
>-
>-      * The descriptor type, (2) above.
>-
>-      * The allocator type, (4) above.  In general, you will not need
>to
>-      provide your own allocator type.  By default, hash tables will
>use
>-      the class template xcallocator, which uses malloc/free for
>allocation.
>-
>-
>-   DEFINING A DESCRIPTOR TYPE
>-
>-   The first task in using the hash table is to describe the element
>type.
>-   We compose this into a few steps.
>-
>-      1. Decide on a removal policy for values stored in the table.
>-         hash-traits.h provides class templates for the four most
>common
>-         policies:
>-
>-         * typed_free_remove implements the static 'remove' member
>function
>-         by calling free().
>-
>-         * typed_noop_remove implements the static 'remove' member
>function
>-         by doing nothing.
>-
>-         * ggc_remove implements the static 'remove' member by doing
>nothing,
>-         but instead provides routines for gc marking and for PCH
>streaming.
>-         Use this for garbage-collected data that needs to be
>preserved across
>-         collections.
>-
>-         * ggc_cache_remove is like ggc_remove, exce


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]