aboutsummaryrefslogtreecommitdiff
path: root/include
diff options
context:
space:
mode:
authorNick Alcock <nick.alcock@oracle.com>2022-03-16 15:29:25 +0000
committerNick Alcock <nick.alcock@oracle.com>2022-03-23 13:48:32 +0000
commit203bfa2f6bd275df4089131bac0a17c278c37a1a (patch)
treecb4b22f42e78f3a9522a4e6b6f149fcc40ae933e /include
parenta12c988767e5bd6b6a15dd6ca5e3b277f5627c64 (diff)
downloadgdb-203bfa2f6bd275df4089131bac0a17c278c37a1a.zip
gdb-203bfa2f6bd275df4089131bac0a17c278c37a1a.tar.gz
gdb-203bfa2f6bd275df4089131bac0a17c278c37a1a.tar.bz2
include, libctf, ld: extend variable section to contain functions too
The CTF variable section is an optional (usually-not-present) section in the CTF dict which contains name -> type mappings corresponding to data symbols that are present in the linker input but not in the output symbol table: the idea is that programs that use their own symbol- resolution mechanisms can use this section to look up the types of symbols they have found using their own mechanism. Because these removed symbols (mostly static variables, functions, etc) all have names that are unlikely to appear in the ELF symtab and because very few programs have their own symbol-resolution mechanisms, a special linker flag (--ctf-variables) is needed to emit this section. Historically, we emitted only removed data symbols into the variable section. This seemed to make sense at the time, but in hindsight it really doesn't: functions are symbols too, and a C program can look them up just like any other type. So extend the variable section so that it contains all static function symbols too (if it is emitted at all), with types of kind CTF_K_FUNCTION. This is a little fiddly. We relied on compiler assistance for data symbols: the compiler simply emits all data symbols twice, once into the symtypetab as an indexed symbol and once into the variable section. Rather than wait for a suitably adjusted compiler that does the same for function symbols, we can pluck unreported function symbols out of the symtab and add them to the variable section ourselves. While we're at it, we do the same with data symbols: this is redundant right now because the compiler does it, but it costs very little time and lets the compiler drop this kludge and save a little space in .o files. include/ * ctf.h: Mention the new things we can see in the variable section. ld/ * testsuite/ld-ctf/data-func-conflicted-vars.d: New test. libctf/ * ctf-link.c (ctf_link_deduplicating_variables): Duplicate symbols into the variable section too. * ctf-serialize.c (symtypetab_delete_nonstatic_vars): Rename to... (symtypetab_delete_nonstatics): ... this. Check the funchash when pruning redundant variables. (ctf_symtypetab_sect_sizes): Adjust accordingly. * NEWS: Describe this change.
Diffstat (limited to 'include')
-rw-r--r--include/ctf.h8
1 files changed, 4 insertions, 4 deletions
diff --git a/include/ctf.h b/include/ctf.h
index 6db2742..698aab3 100644
--- a/include/ctf.h
+++ b/include/ctf.h
@@ -89,13 +89,13 @@ extern "C"
entries and reorder them accordingly (dropping the indexes in the process).
Variable records (as distinct from data objects) provide a modicum of support
- for non-ELF systems, mapping a variable name to a CTF type ID. The variable
- names are sorted into ASCIIbetical order, permitting binary searching. We do
- not define how the consumer maps these variable names to addresses or
+ for non-ELF systems, mapping a variable or function name to a CTF type ID.
+ The names are sorted into ASCIIbetical order, permitting binary searching.
+ We do not define how the consumer maps these variable names to addresses or
anything else, or indeed what these names represent: they might be names
looked up at runtime via dlsym() or names extracted at runtime by a debugger
or anything else the consumer likes. Variable records with identically-
- named entries in the data object section are removed.
+ named entries in the data object or function index section are removed.
The data types section is a list of variable size records that represent each
type, in order by their ID. The types themselves form a directed graph,