aboutsummaryrefslogtreecommitdiff
path: root/libctf/ctf-util.c
diff options
context:
space:
mode:
authorNick Alcock <nick.alcock@oracle.com>2019-06-27 13:51:10 +0100
committerNick Alcock <nick.alcock@oracle.com>2019-07-01 11:05:59 +0100
commitf5e9c9bde04ae52b92027b78c9ca20055f1afb78 (patch)
tree99f8b4e2e938d6195ca0ad6842e2a3a9676da6bb /libctf/ctf-util.c
parent9658dc39630b8ac4e849fb529a53902da5fc2b1f (diff)
downloadgdb-f5e9c9bde04ae52b92027b78c9ca20055f1afb78.zip
gdb-f5e9c9bde04ae52b92027b78c9ca20055f1afb78.tar.gz
gdb-f5e9c9bde04ae52b92027b78c9ca20055f1afb78.tar.bz2
libctf: deduplicate and sort the string table
ctf.h states: > [...] the CTF string table does not contain any duplicated strings. Unfortunately this is entirely untrue: libctf has before now made no attempt whatsoever to deduplicate the string table. It computes the string table's length on the fly as it adds new strings to the dynamic CTF file, and ctf_update() just writes each string to the table and notes the current write position as it traverses the dynamic CTF file's data structures and builds the final CTF buffer. There is no global view of the strings and no deduplication. Fix this by erasing the ctf_dtvstrlen dead-reckoning length, and adding a new dynhash table ctf_str_atoms that maps unique strings to a list of references to those strings: a reference is a simple uint32_t * to some value somewhere in the under-construction CTF buffer that needs updating to note the string offset when the strtab is laid out. Adding a string is now a simple matter of calling ctf_str_add_ref(), which adds a new atom to the atoms table, if one doesn't already exist, and adding the location of the reference to this atom to the refs list attached to the atom: this works reliably as long as one takes care to only call ctf_str_add_ref() once the final location of the offset is known (so you can't call it on a temporary structure and then memcpy() that structure into place in the CTF buffer, because the ref will still point to the old location: ctf_update() changes accordingly). Generating the CTF string table is a matter of calling ctf_str_write_strtab(), which counts the length and number of elements in the atoms table using the ctf_dynhash_iter() function we just added, populating an array of pointers into the atoms table and sorting it into order (to help compressors), then traversing this table and emitting it, updating the refs to each atom as we go. The only complexity here is arranging to keep the null string at offset zero, since a lot of code in libctf depends on being able to leave strtab references at 0 to indicate 'no name'. Once the table is constructed and the refs updated, we know how long it is, so we can realloc() the partial CTF buffer we allocated earlier and can copy the table on to the end of it (and purge the refs because they're not needed any more and have been invalidated by the realloc() call in any case). The net effect of all this is a reduction in uncompressed strtab sizes of about 30% (perhaps a quarter to a half of all strings across the Linux kernel are eliminated as duplicates). Of course, duplicated strings are highly redundant, so the space saving after compression is only about 20%: when the other non-strtab sections are factored in, CTF sizes shrink by about 10%. No change in externally-visible API or file format (other than the reduction in pointless redundancy). libctf/ * ctf-impl.h: (struct ctf_strs_writable): New, non-const version of struct ctf_strs. (struct ctf_dtdef): Note that dtd_data.ctt_name is unpopulated. (struct ctf_str_atom): New, disambiguated single string. (struct ctf_str_atom_ref): New, points to some other location that references this string's offset. (struct ctf_file): New members ctf_str_atoms and ctf_str_num_refs. Remove member ctf_dtvstrlen: we no longer track the total strlen as we add strings. (ctf_str_create_atoms): Declare new function in ctf-string.c. (ctf_str_free_atoms): Likewise. (ctf_str_add): Likewise. (ctf_str_add_ref): Likewise. (ctf_str_purge_refs): Likewise. (ctf_str_write_strtab): Likewise. (ctf_realloc): Declare new function in ctf-util.c. * ctf-open.c (ctf_bufopen): Create the atoms table. (ctf_file_close): Destroy it. * ctf-create.c (ctf_update): Copy-and-free it on update. No longer special-case the position of the parname string. Construct the strtab by calling ctf_str_add_ref and ctf_str_write_strtab after the rest of each buffer element is constructed, not via open-coding: realloc the CTF buffer and append the strtab to it. No longer maintain ctf_dtvstrlen. Sort the variable entry table later, after strtab construction. (ctf_copy_membnames): Remove: integrated into ctf_copy_{s,l,e}members. (ctf_copy_smembers): Drop the string offset: call ctf_str_add_ref after buffer element construction instead. (ctf_copy_lmembers): Likewise. (ctf_copy_emembers): Likewise. (ctf_create): No longer maintain the ctf_dtvstrlen. (ctf_dtd_delete): Likewise. (ctf_dvd_delete): Likewise. (ctf_add_generic): Likewise. (ctf_add_enumerator): Likewise. (ctf_add_member_offset): Likewise. (ctf_add_variable): Likewise. (membadd): Likewise. * ctf-util.c (ctf_realloc): New, wrapper around realloc that aborts if there are active ctf_str_num_refs. (ctf_strraw): Move to ctf-string.c. (ctf_strptr): Likewise. * ctf-string.c: New file, strtab manipulation. * Makefile.am (libctf_a_SOURCES): Add it. * Makefile.in: Regenerate.
Diffstat (limited to 'libctf/ctf-util.c')
-rw-r--r--libctf/ctf-util.c35
1 files changed, 13 insertions, 22 deletions
diff --git a/libctf/ctf-util.c b/libctf/ctf-util.c
index 730f358..b813c0d 100644
--- a/libctf/ctf-util.c
+++ b/libctf/ctf-util.c
@@ -95,28 +95,6 @@ ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst)
return dst;
}
-/* Convert an encoded CTF string name into a pointer to a C string by looking
- up the appropriate string table buffer and then adding the offset. */
-
-const char *
-ctf_strraw (ctf_file_t *fp, uint32_t name)
-{
- ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID (name)];
-
- if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET (name) < ctsp->cts_len)
- return (ctsp->cts_strs + CTF_NAME_OFFSET (name));
-
- /* String table not loaded or corrupt offset. */
- return NULL;
-}
-
-const char *
-ctf_strptr (ctf_file_t *fp, uint32_t name)
-{
- const char *s = ctf_strraw (fp, name);
- return (s != NULL ? s : "(?)");
-}
-
/* Same as strdup(3C), but use ctf_alloc() to do the memory allocation. */
_libctf_malloc_ char *
@@ -154,6 +132,19 @@ ctf_str_append (char *s, const char *append)
return s;
}
+/* A realloc() that fails noisily if called with any ctf_str_num_users. */
+void *
+ctf_realloc (ctf_file_t *fp, void *ptr, size_t size)
+{
+ if (fp->ctf_str_num_refs > 0)
+ {
+ ctf_dprintf ("%p: attempt to realloc() string table with %lu active refs\n",
+ (void *) fp, (unsigned long) fp->ctf_str_num_refs);
+ return NULL;
+ }
+ return realloc (ptr, size);
+}
+
/* Store the specified error code into errp if it is non-NULL, and then
return NULL for the benefit of the caller. */