diff options
author | Tom Tromey <tom@tromey.com> | 2019-03-07 04:20:19 -0700 |
---|---|---|
committer | Tom Tromey <tom@tromey.com> | 2019-03-07 10:48:02 -0700 |
commit | 25629dfdb438c82f2bb711174042bb326a526aaf (patch) | |
tree | f0bd8f98faa31b5124de5963abe119507a095622 /gdb/bcache.h | |
parent | fe7266674110f34eacf2e9d2b308f76d33ce50ed (diff) | |
download | gdb-25629dfdb438c82f2bb711174042bb326a526aaf.zip gdb-25629dfdb438c82f2bb711174042bb326a526aaf.tar.gz gdb-25629dfdb438c82f2bb711174042bb326a526aaf.tar.bz2 |
C++-ify bcache
This somewhat C++-ifies bcache. It replaces bcache_xmalloc and
bcache_xfree with constructors; changes some functions into methods;
and changes various structures to include a bcache directly (as
opposed to a pointer to a bcache).
Tested by the buildbot.
gdb/ChangeLog
2019-03-07 Tom Tromey <tom@tromey.com>
* symmisc.c (print_symbol_bcache_statistics): Update.
(print_objfile_statistics): Update.
* symfile.c (allocate_symtab): Update.
* stabsread.c: Don't include bcache.h.
* psymtab.h (struct psymbol_bcache): Don't declare.
(class psymtab_storage) <psymbol_cache>: Now a bcache.
(psymbol_bcache_init, psymbol_bcache_free)
(psymbol_bcache_get_bcache): Don't declare.
* psymtab.c (struct psymbol_bcache): Remove.
(psymtab_storage::psymtab_storage): Update.
(psymtab_storage::~psymtab_storage): Update.
(psymbol_bcache_init, psymbol_bcache_free)
(psymbol_bcache_get_bcache, psymbol_bcache_full): Remove.
(add_psymbol_to_bcache): Update.
(allocate_psymtab): Update.
* objfiles.h (struct objfile_per_bfd_storage) <filename_cache,
macro_cache>: No longer pointers.
* objfiles.c (get_objfile_bfd_data): Don't call bcache_xmalloc.
(free_objfile_per_bfd_storage): Don't call bcache_xfree.
* macrotab.c (macro_bcache): Update.
* macroexp.c: Don't include bcache.h.
* gdbtypes.c (check_types_worklist): Update.
(types_deeply_equal): Remove TRY/CATCH. Update.
* elfread.c (elf_symtab_read): Update.
* dwarf2read.c: Don't include bcache.h.
* buildsym.c (buildsym_compunit::get_macro_table): Update.
* bcache.h (bcache, bcache_full, bcache_xffree, bcache_xmalloc)
(print_bcache_statistics, bcache_memory_used): Don't declare.
(struct bcache): Move from bcache.c. Add constructor, destructor,
methods. Rename all data members.
* bcache.c (struct bcache): Move to bcache.h.
(bcache::expand_hash_table): Rename from expand_hash_table.
(bcache): Remove.
(bcache::insert): Rename from bcache_full.
(bcache::compare): Rename from bcache_compare.
(bcache_xmalloc): Remove.
(bcache::~bcache): Rename from bcache_xfree.
(bcache::print_statistics): Rename from print_bcache_statistics.
(bcache::memory_used): Rename from bcache_memory_used.
Diffstat (limited to 'gdb/bcache.h')
-rw-r--r-- | gdb/bcache.h | 112 |
1 files changed, 80 insertions, 32 deletions
diff --git a/gdb/bcache.h b/gdb/bcache.h index aa014792..15dcc63 100644 --- a/gdb/bcache.h +++ b/gdb/bcache.h @@ -136,41 +136,89 @@ */ - -struct bcache; - -/* Find a copy of the LENGTH bytes at ADDR in BCACHE. If BCACHE has - never seen those bytes before, add a copy of them to BCACHE. In - either case, return a pointer to BCACHE's copy of that string. - Since the cached value is ment to be read-only, return a const - buffer. */ -extern const void *bcache (const void *addr, int length, - struct bcache *bcache); - -/* Like bcache, but if ADDED is not NULL, set *ADDED to true if the - bytes were newly added to the cache, or to false if the bytes were - found in the cache. */ -extern const void *bcache_full (const void *addr, int length, - struct bcache *bcache, int *added); - -/* Free all the storage used by BCACHE. */ -extern void bcache_xfree (struct bcache *bcache); - -/* Create a new bcache object. */ -extern struct bcache *bcache_xmalloc ( - unsigned long (*hash_function)(const void *, int length), - int (*compare_function)(const void *, const void *, int length)); - -/* Print statistics on BCACHE's memory usage and efficacity at - eliminating duplication. TYPE should be a string describing the - kind of data BCACHE holds. Statistics are printed using - `printf_filtered' and its ilk. */ -extern void print_bcache_statistics (struct bcache *bcache, const char *type); -extern int bcache_memory_used (struct bcache *bcache); +struct bstring; /* The hash functions */ -extern unsigned long hash(const void *addr, int length); +extern unsigned long hash (const void *addr, int length); extern unsigned long hash_continue (const void *addr, int length, unsigned long h); +struct bcache +{ + /* Allocate a bcache. HASH_FN and COMPARE_FN can be used to pass in + custom hash, and compare functions to be used by this bcache. If + HASH_FUNCTION is NULL hash() is used and if COMPARE_FUNCTION is + NULL memcmp() is used. */ + + explicit bcache (unsigned long (*hash_fn)(const void *, + int length) = nullptr, + int (*compare_fn)(const void *, const void *, + int length) = nullptr) + : m_hash_function (hash_fn == nullptr ? hash : hash_fn), + m_compare_function (compare_fn == nullptr ? compare : compare_fn) + { + } + + ~bcache (); + + /* Find a copy of the LENGTH bytes at ADDR in BCACHE. If BCACHE has + never seen those bytes before, add a copy of them to BCACHE. In + either case, return a pointer to BCACHE's copy of that string. + Since the cached value is ment to be read-only, return a const + buffer. If ADDED is not NULL, set *ADDED to true if the bytes + were newly added to the cache, or to false if the bytes were + found in the cache. */ + + const void *insert (const void *addr, int length, int *added = nullptr); + + /* Print statistics on this bcache's memory usage and efficacity at + eliminating duplication. TYPE should be a string describing the + kind of data this bcache holds. Statistics are printed using + `printf_filtered' and its ilk. */ + void print_statistics (const char *type); + int memory_used (); + +private: + + /* All the bstrings are allocated here. */ + struct obstack m_cache {}; + + /* How many hash buckets we're using. */ + unsigned int m_num_buckets = 0; + + /* Hash buckets. This table is allocated using malloc, so when we + grow the table we can return the old table to the system. */ + struct bstring **m_bucket = nullptr; + + /* Statistics. */ + unsigned long m_unique_count = 0; /* number of unique strings */ + long m_total_count = 0; /* total number of strings cached, including dups */ + long m_unique_size = 0; /* size of unique strings, in bytes */ + long m_total_size = 0; /* total number of bytes cached, including dups */ + long m_structure_size = 0; /* total size of bcache, including infrastructure */ + /* Number of times that the hash table is expanded and hence + re-built, and the corresponding number of times that a string is + [re]hashed as part of entering it into the expanded table. The + total number of hashes can be computed by adding TOTAL_COUNT to + expand_hash_count. */ + unsigned long m_expand_count = 0; + unsigned long m_expand_hash_count = 0; + /* Number of times that the half-hash compare hit (compare the upper + 16 bits of hash values) hit, but the corresponding combined + length/data compare missed. */ + unsigned long m_half_hash_miss_count = 0; + + /* Hash function to be used for this bcache object. */ + unsigned long (*m_hash_function)(const void *addr, int length); + + /* Compare function to be used for this bcache object. */ + int (*m_compare_function)(const void *, const void *, int length); + + /* Default compare function. */ + static int compare (const void *addr1, const void *addr2, int length); + + /* Expand the hash table. */ + void expand_hash_table (); +}; + #endif /* BCACHE_H */ |