2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_getsymsect): New.
|
|
|
|
|
|
(ctf_getstrsect): Likewise.
|
|
|
|
|
|
* libctf.ver: Add them.
|
|
|
|
|
|
|
libctf, include: CTF-archive-wide symbol lookup
CTF archives may contain multiple dicts, each of which contain many
types and possibly a bunch of symtypetab entries relating to those
types: each symtypetab entry is going to appear in exactly one dict,
with the corresponding entries in the other dicts empty (either pads, or
indexed symtypetabs that do not mention that symbol). But users of
libctf usually want to get back the type associated with a symbol
without having to dig around to find out which dict that type might be
in.
This adds machinery to do that -- and since you probably want to do it
repeatedly, it adds internal caching to the ctf-archive machinery so
that iteration over archives via ctf_archive_next and repeated symbol
lookups do not have to repeatedly reopen the archive. (Iteration using
ctf_archive_iter will gain caching soon.)
Two new API functions:
ctf_dict_t *
ctf_arc_lookup_symbol (ctf_archive_t *arc, unsigned long symidx,
ctf_id_t *typep, int *errp);
This looks up the symbol with index SYMIDX in the archive ARC, returning
the dictionary in which it resides and optionally the type index as
well. Errors are returned in ERRP. The dict should be
ctf_dict_close()d when done, but is also cached inside the ctf_archive
so that the open cost is only paid once. The result of the symbol
lookup is also cached internally, so repeated lookups of the same symbol
are nearly free.
void ctf_arc_flush_caches (ctf_archive_t *arc);
Flush all the caches. Done at close time, but also available as an API
function if users want to do it by hand.
include/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ctf_arc_lookup_symbol): New.
(ctf_arc_flush_caches): Likewise.
* ctf.h: Document new auto-ctf_import behaviour.
libctf/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-impl.h (struct ctf_archive_internal) <ctfi_dicts>: New, dicts
the archive machinery has opened and cached.
<ctfi_symdicts>: New, cache of dicts containing symbols looked up.
<ctfi_syms>: New, cache of types of symbols looked up.
* ctf-archive.c (ctf_arc_close): Free them on close.
(enosym): New, flag entry for 'symbol not present'.
(ctf_arc_import_parent): New, automatically import the parent from
".ctf" if this is a child in an archive and ".ctf" is present.
(ctf_dict_open_sections): Use it.
(ctf_archive_iter_internal): Likewise.
(ctf_cached_dict_close): New, thunk around ctf_dict_close.
(ctf_dict_open_cached): New, open and cache a dict.
(ctf_arc_flush_caches): New, flush the caches.
(ctf_arc_lookup_symbol): New, look up a symbol in (all members of)
an archive, and cache the lookup.
(ctf_archive_iter): Note the new caching behaviour.
(ctf_archive_next): Use ctf_dict_open_cached.
* libctf.ver: Add ctf_arc_lookup_symbol and ctf_arc_flush_caches.
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (struct ctf_archive_internal) <ctfi_dicts>: New, dicts
|
|
|
|
|
|
the archive machinery has opened and cached.
|
|
|
|
|
|
<ctfi_symdicts>: New, cache of dicts containing symbols looked up.
|
|
|
|
|
|
<ctfi_syms>: New, cache of types of symbols looked up.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_close): Free them on close.
|
|
|
|
|
|
(enosym): New, flag entry for 'symbol not present'.
|
|
|
|
|
|
(ctf_arc_import_parent): New, automatically import the parent from
|
|
|
|
|
|
".ctf" if this is a child in an archive and ".ctf" is present.
|
|
|
|
|
|
(ctf_dict_open_sections): Use it.
|
|
|
|
|
|
(ctf_archive_iter_internal): Likewise.
|
|
|
|
|
|
(ctf_cached_dict_close): New, thunk around ctf_dict_close.
|
|
|
|
|
|
(ctf_dict_open_cached): New, open and cache a dict.
|
|
|
|
|
|
(ctf_arc_flush_caches): New, flush the caches.
|
|
|
|
|
|
(ctf_arc_lookup_symbol): New, look up a symbol in (all members of)
|
|
|
|
|
|
an archive, and cache the lookup.
|
|
|
|
|
|
(ctf_archive_iter): Note the new caching behaviour.
|
|
|
|
|
|
(ctf_archive_next): Use ctf_dict_open_cached.
|
|
|
|
|
|
* libctf.ver: Add ctf_arc_lookup_symbol and ctf_arc_flush_caches.
|
|
|
|
|
|
|
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dedup.c (ctf_dedup_rhash_type): Null out the names of nameless
|
|
|
|
|
|
type kinds, just in case the input has named them.
|
|
|
|
|
|
|
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_header): Dump the new flags bits and the index
|
|
|
|
|
|
section lengths.
|
|
|
|
|
|
(ctf_dump_objts): Report indexed sections. Also dump functions. Use
|
|
|
|
|
|
ctf_symbol_next, not manual looping.
|
|
|
|
|
|
(ctf_dump_funcs): Delete.
|
|
|
|
|
|
(ctf_dump): Use ctf_dump_objts, not ctf_dump_funcs.
|
|
|
|
|
|
|
libctf: symbol type linking support
This adds facilities to write out the function info and data object
sections, which efficiently map from entries in the symbol table to
types. The write-side code is entirely new: the read-side code was
merely significantly changed and support for indexed tables added
(pointed to by the no-longer-unused cth_objtidxoff and cth_funcidxoff
header fields).
With this in place, you can use ctf_lookup_by_symbol to look up the
types of symbols of function and object type (and, as before, you can
use ctf_lookup_variable to look up types of file-scope variables not
present in the symbol table, as long as you know their name: but
variables that are also data objects are now found in the data object
section instead.)
(Compatible) file format change:
The CTF spec has always said that the function info section looks much
like the CTF_K_FUNCTIONs in the type section: an info word (including an
argument count) followed by a return type and N argument types. This
format is suboptimal: it means function symbols cannot be deduplicated
and it causes a lot of ugly code duplication in libctf. But
conveniently the compiler has never emitted this! Because it has always
emitted a rather different format that libctf has never accepted, we can
be sure that there are no instances of this function info section in the
wild, and can freely change its format without compatibility concerns or
a file format version bump. (And since it has never been emitted in any
code that generated any older file format version, either, we need keep
no code to read the format as specified at all!)
So the function info section is now specified as an array of uint32_t,
exactly like the object data section: each entry is a type ID in the
type section which must be of kind CTF_K_FUNCTION, the prototype of
this function.
This allows function types to be deduplicated and also correctly encodes
the fact that all functions declared in C really are types available to
the program: so they should be stored in the type section like all other
types. (In format v4, we will be able to represent the types of static
functions as well, but that really does require a file format change.)
We introduce a new header flag, CTF_F_NEWFUNCINFO, which is set if the
new function info format is in use. A sufficiently new compiler will
always set this flag. New libctf will always set this flag: old libctf
will refuse to open any CTF dicts that have this flag set. If the flag
is not set on a dict being read in, new libctf will disregard the
function info section. Format v4 will remove this flag (or, rather, the
flag has no meaning there and the bit position may be recycled for some
other purpose).
New API:
Symbol addition:
ctf_add_func_sym: Add a symbol with a given name and type. The
type must be of kind CTF_K_FUNCTION (a function
pointer). Internally this adds a name -> type
mapping to the ctf_funchash in the ctf_dict.
ctf_add_objt_sym: Add a symbol with a given name and type. The type
kind can be anything, including function pointers.
This adds to ctf_objthash.
These both treat symbols as name -> type mappings: the linker associates
symbol names with symbol indexes via the ctf_link_shuffle_syms callback,
which sets up the ctf_dynsyms/ctf_dynsymidx/ctf_dynsymmax fields in the
ctf_dict. Repeated relinks can add more symbols.
Variables that are also exposed as symbols are removed from the variable
section at serialization time.
CTF symbol type sections which have enough pads, defined by
CTF_INDEX_PAD_THRESHOLD (whether because they are in dicts with symbols
where most types are unknown, or in archive where most types are defined
in some child or parent dict, not in this specific dict) are sorted by
name rather than symidx and accompanied by an index which associates
each symbol type entry with a name: the existing ctf_lookup_by_symbol
will map symbol indexes to symbol names and look the names up in the
index automatically. (This is currently ELF-symbol-table-dependent, but
there is almost nothing specific to ELF in here and we can add support
for other symbol table formats easily).
The compiler also uses index sections to communicate the contents of
object file symbol tables without relying on any specific ordering of
symbols: it doesn't need to sort them, and libctf will detect an
unsorted index section via the absence of the new CTF_F_IDXSORTED header
flag, and sort it if needed.
Iteration:
ctf_symbol_next: Iterator which returns the types and names of symbols
one by one, either for function or data symbols.
This does not require any sorting: the ctf_link machinery uses it to
pull in all the compiler-provided symbols cheaply, but it is not
restricted to that use.
(Compatible) changes in API:
ctf_lookup_by_symbol: can now be called for object and function
symbols: never returns ECTF_NOTDATA (which is
now not thrown by anything, but is kept for
compatibility and because it is a plausible
error that we might start throwing again at some
later date).
Internally we also have changes to the ctf-string functionality so that
"external" strings (those where we track a string -> offset mapping, but
only write out an offset) can be consulted via the usual means
(ctf_strptr) before the strtab is written out. This is important
because ctf_link_add_linker_symbol can now be handed symbols named via
strtab offsets, and ctf_link_shuffle_syms must figure out their actual
names by looking in the external symtab we have just been fed by the
ctf_link_add_strtab callback, long before that strtab is written out.
include/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ctf_symbol_next): New.
(ctf_add_objt_sym): Likewise.
(ctf_add_func_sym): Likewise.
* ctf.h: Document new function info section format.
(CTF_F_NEWFUNCINFO): New.
(CTF_F_IDXSORTED): New.
(CTF_F_MAX): Adjust accordingly.
libctf/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-impl.h (CTF_INDEX_PAD_THRESHOLD): New.
(_libctf_nonnull_): Likewise.
(ctf_in_flight_dynsym_t): New.
(ctf_dict_t) <ctf_funcidx_names>: Likewise.
<ctf_objtidx_names>: Likewise.
<ctf_nfuncidx>: Likewise.
<ctf_nobjtidx>: Likewise.
<ctf_funcidx_sxlate>: Likewise.
<ctf_objtidx_sxlate>: Likewise.
<ctf_objthash>: Likewise.
<ctf_funchash>: Likewise.
<ctf_dynsyms>: Likewise.
<ctf_dynsymidx>: Likewise.
<ctf_dynsymmax>: Likewise.
<ctf_in_flight_dynsym>: Likewise.
(struct ctf_next) <u.ctn_next>: Likewise.
(ctf_symtab_skippable): New prototype.
(ctf_add_funcobjt_sym): Likewise.
(ctf_dynhash_sort_by_name): Likewise.
(ctf_sym_to_elf64): Rename to...
(ctf_elf32_to_link_sym): ... this, and...
(ctf_elf64_to_link_sym): ... this.
* ctf-open.c (init_symtab): Check for lack of CTF_F_NEWFUNCINFO
flag, and presence of index sections. Refactor out
ctf_symtab_skippable and ctf_elf*_to_link_sym, and use them. Use
ctf_link_sym_t, not Elf64_Sym. Skip initializing objt or func
sxlate sections if corresponding index section is present. Adjust
for new func info section format.
(ctf_bufopen_internal): Add ctf_err_warn to corrupt-file error
handling. Report incorrect-length index sections. Always do an
init_symtab, even if there is no symtab section (there may be index
sections still).
(flip_objts): Adjust comment: func and objt sections are actually
identical in structure now, no need to caveat.
(ctf_dict_close): Free newly-added data structures.
* ctf-create.c (ctf_create): Initialize them.
(ctf_symtab_skippable): New, refactored out of
init_symtab, with st_nameidx_set check added.
(ctf_add_funcobjt_sym): New, add a function or object symbol to the
ctf_objthash or ctf_funchash, by name.
(ctf_add_objt_sym): Call it.
(ctf_add_func_sym): Likewise.
(symtypetab_delete_nonstatic_vars): New, delete vars also present as
data objects.
(CTF_SYMTYPETAB_EMIT_FUNCTION): New flag to symtypetab emitters:
this is a function emission, not a data object emission.
(CTF_SYMTYPETAB_EMIT_PAD): New flag to symtypetab emitters: emit
pads for symbols with no type (only set for unindexed sections).
(CTF_SYMTYPETAB_FORCE_INDEXED): New flag to symtypetab emitters:
always emit indexed.
(symtypetab_density): New, figure out section sizes.
(emit_symtypetab): New, emit a symtypetab.
(emit_symtypetab_index): New, emit a symtypetab index.
(ctf_serialize): Call them, emitting suitably sorted symtypetab
sections and indexes. Set suitable header flags. Copy over new
fields.
* ctf-hash.c (ctf_dynhash_sort_by_name): New, used to impose an
order on symtypetab index sections.
* ctf-link.c (ctf_add_type_mapping): Delete erroneous comment
relating to code that was never committed.
(ctf_link_one_variable): Improve variable name.
(check_sym): New, symtypetab analogue of check_variable.
(ctf_link_deduplicating_one_symtypetab): New.
(ctf_link_deduplicating_syms): Likewise.
(ctf_link_deduplicating): Call them.
(ctf_link_deduplicating_per_cu): Note that we don't call them in
this case (yet).
(ctf_link_add_strtab): Set the error on the fp correctly.
(ctf_link_add_linker_symbol): New (no longer a do-nothing stub), add
a linker symbol to the in-flight list.
(ctf_link_shuffle_syms): New (no longer a do-nothing stub), turn the
in-flight list into a mapping we can use, now its names are
resolvable in the external strtab.
* ctf-string.c (ctf_str_rollback_atom): Don't roll back atoms with
external strtab offsets.
(ctf_str_rollback): Adjust comment.
(ctf_str_write_strtab): Migrate ctf_syn_ext_strtab population from
writeout time...
(ctf_str_add_external): ... to string addition time.
* ctf-lookup.c (ctf_lookup_var_key_t): Rename to...
(ctf_lookup_idx_key_t): ... this, now we use it for syms too.
<clik_names>: New member, a name table.
(ctf_lookup_var): Adjust accordingly.
(ctf_lookup_variable): Likewise.
(ctf_lookup_by_id): Shuffle further up in the file.
(ctf_symidx_sort_arg_cb): New, callback for...
(sort_symidx_by_name): ... this new function to sort a symidx
found to be unsorted (likely originating from the compiler).
(ctf_symidx_sort): New, sort a symidx.
(ctf_lookup_symbol_name): Support dynamic symbols with indexes
provided by the linker. Use ctf_link_sym_t, not Elf64_Sym.
Check the parent if a child lookup fails.
(ctf_lookup_by_symbol): Likewise. Work for function symbols too.
(ctf_symbol_next): New, iterate over symbols with types (without
sorting).
(ctf_lookup_idx_name): New, bsearch for symbol names in indexes.
(ctf_try_lookup_indexed): New, attempt an indexed lookup.
(ctf_func_info): Reimplement in terms of ctf_lookup_by_symbol.
(ctf_func_args): Likewise.
(ctf_get_dict): Move...
* ctf-types.c (ctf_get_dict): ... here.
* ctf-util.c (ctf_sym_to_elf64): Re-express as...
(ctf_elf64_to_link_sym): ... this. Add new st_symidx field, and
st_nameidx_set (always 0, so st_nameidx can be ignored). Look in
the ELF strtab for names.
(ctf_elf32_to_link_sym): Likewise, for Elf32_Sym.
(ctf_next_destroy): Destroy ctf_next_t.u.ctn_next if need be.
* libctf.ver: Add ctf_symbol_next, ctf_add_objt_sym and
ctf_add_func_sym.
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (CTF_INDEX_PAD_THRESHOLD): New.
|
|
|
|
|
|
(_libctf_nonnull_): Likewise.
|
|
|
|
|
|
(ctf_in_flight_dynsym_t): New.
|
|
|
|
|
|
(ctf_dict_t) <ctf_funcidx_names>: Likewise.
|
|
|
|
|
|
<ctf_objtidx_names>: Likewise.
|
|
|
|
|
|
<ctf_nfuncidx>: Likewise.
|
|
|
|
|
|
<ctf_nobjtidx>: Likewise.
|
|
|
|
|
|
<ctf_funcidx_sxlate>: Likewise.
|
|
|
|
|
|
<ctf_objtidx_sxlate>: Likewise.
|
|
|
|
|
|
<ctf_objthash>: Likewise.
|
|
|
|
|
|
<ctf_funchash>: Likewise.
|
|
|
|
|
|
<ctf_dynsyms>: Likewise.
|
|
|
|
|
|
<ctf_dynsymidx>: Likewise.
|
|
|
|
|
|
<ctf_dynsymmax>: Likewise.
|
|
|
|
|
|
<ctf_in_flight_dynsym>: Likewise.
|
|
|
|
|
|
(struct ctf_next) <u.ctn_next>: Likewise.
|
|
|
|
|
|
(ctf_symtab_skippable): New prototype.
|
|
|
|
|
|
(ctf_add_funcobjt_sym): Likewise.
|
|
|
|
|
|
(ctf_dynhash_sort_by_name): Likewise.
|
|
|
|
|
|
(ctf_sym_to_elf64): Rename to...
|
|
|
|
|
|
(ctf_elf32_to_link_sym): ... this, and...
|
|
|
|
|
|
(ctf_elf64_to_link_sym): ... this.
|
|
|
|
|
|
* ctf-open.c (init_symtab): Check for lack of CTF_F_NEWFUNCINFO
|
|
|
|
|
|
flag, and presence of index sections. Refactor out
|
|
|
|
|
|
ctf_symtab_skippable and ctf_elf*_to_link_sym, and use them. Use
|
|
|
|
|
|
ctf_link_sym_t, not Elf64_Sym. Skip initializing objt or func
|
|
|
|
|
|
sxlate sections if corresponding index section is present. Adjust
|
|
|
|
|
|
for new func info section format.
|
|
|
|
|
|
(ctf_bufopen_internal): Add ctf_err_warn to corrupt-file error
|
|
|
|
|
|
handling. Report incorrect-length index sections. Always do an
|
|
|
|
|
|
init_symtab, even if there is no symtab section (there may be index
|
|
|
|
|
|
sections still).
|
|
|
|
|
|
(flip_objts): Adjust comment: func and objt sections are actually
|
|
|
|
|
|
identical in structure now, no need to caveat.
|
|
|
|
|
|
(ctf_dict_close): Free newly-added data structures.
|
|
|
|
|
|
* ctf-create.c (ctf_create): Initialize them.
|
|
|
|
|
|
(ctf_symtab_skippable): New, refactored out of
|
|
|
|
|
|
init_symtab, with st_nameidx_set check added.
|
|
|
|
|
|
(ctf_add_funcobjt_sym): New, add a function or object symbol to the
|
|
|
|
|
|
ctf_objthash or ctf_funchash, by name.
|
|
|
|
|
|
(ctf_add_objt_sym): Call it.
|
|
|
|
|
|
(ctf_add_func_sym): Likewise.
|
|
|
|
|
|
(symtypetab_delete_nonstatic_vars): New, delete vars also present as
|
|
|
|
|
|
data objects.
|
|
|
|
|
|
(CTF_SYMTYPETAB_EMIT_FUNCTION): New flag to symtypetab emitters:
|
|
|
|
|
|
this is a function emission, not a data object emission.
|
|
|
|
|
|
(CTF_SYMTYPETAB_EMIT_PAD): New flag to symtypetab emitters: emit
|
|
|
|
|
|
pads for symbols with no type (only set for unindexed sections).
|
|
|
|
|
|
(CTF_SYMTYPETAB_FORCE_INDEXED): New flag to symtypetab emitters:
|
|
|
|
|
|
always emit indexed.
|
|
|
|
|
|
(symtypetab_density): New, figure out section sizes.
|
|
|
|
|
|
(emit_symtypetab): New, emit a symtypetab.
|
|
|
|
|
|
(emit_symtypetab_index): New, emit a symtypetab index.
|
|
|
|
|
|
(ctf_serialize): Call them, emitting suitably sorted symtypetab
|
|
|
|
|
|
sections and indexes. Set suitable header flags. Copy over new
|
|
|
|
|
|
fields.
|
|
|
|
|
|
* ctf-hash.c (ctf_dynhash_sort_by_name): New, used to impose an
|
|
|
|
|
|
order on symtypetab index sections.
|
|
|
|
|
|
* ctf-link.c (ctf_add_type_mapping): Delete erroneous comment
|
|
|
|
|
|
relating to code that was never committed.
|
|
|
|
|
|
(ctf_link_one_variable): Improve variable name.
|
|
|
|
|
|
(check_sym): New, symtypetab analogue of check_variable.
|
|
|
|
|
|
(ctf_link_deduplicating_one_symtypetab): New.
|
|
|
|
|
|
(ctf_link_deduplicating_syms): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating): Call them.
|
|
|
|
|
|
(ctf_link_deduplicating_per_cu): Note that we don't call them in
|
|
|
|
|
|
this case (yet).
|
|
|
|
|
|
(ctf_link_add_strtab): Set the error on the fp correctly.
|
|
|
|
|
|
(ctf_link_add_linker_symbol): New (no longer a do-nothing stub), add
|
|
|
|
|
|
a linker symbol to the in-flight list.
|
|
|
|
|
|
(ctf_link_shuffle_syms): New (no longer a do-nothing stub), turn the
|
|
|
|
|
|
in-flight list into a mapping we can use, now its names are
|
|
|
|
|
|
resolvable in the external strtab.
|
|
|
|
|
|
* ctf-string.c (ctf_str_rollback_atom): Don't roll back atoms with
|
|
|
|
|
|
external strtab offsets.
|
|
|
|
|
|
(ctf_str_rollback): Adjust comment.
|
|
|
|
|
|
(ctf_str_write_strtab): Migrate ctf_syn_ext_strtab population from
|
|
|
|
|
|
writeout time...
|
|
|
|
|
|
(ctf_str_add_external): ... to string addition time.
|
|
|
|
|
|
* ctf-lookup.c (ctf_lookup_var_key_t): Rename to...
|
|
|
|
|
|
(ctf_lookup_idx_key_t): ... this, now we use it for syms too.
|
|
|
|
|
|
<clik_names>: New member, a name table.
|
|
|
|
|
|
(ctf_lookup_var): Adjust accordingly.
|
|
|
|
|
|
(ctf_lookup_variable): Likewise.
|
|
|
|
|
|
(ctf_lookup_by_id): Shuffle further up in the file.
|
|
|
|
|
|
(ctf_symidx_sort_arg_cb): New, callback for...
|
|
|
|
|
|
(sort_symidx_by_name): ... this new function to sort a symidx
|
|
|
|
|
|
found to be unsorted (likely originating from the compiler).
|
|
|
|
|
|
(ctf_symidx_sort): New, sort a symidx.
|
|
|
|
|
|
(ctf_lookup_symbol_name): Support dynamic symbols with indexes
|
|
|
|
|
|
provided by the linker. Use ctf_link_sym_t, not Elf64_Sym.
|
|
|
|
|
|
Check the parent if a child lookup fails.
|
|
|
|
|
|
(ctf_lookup_by_symbol): Likewise. Work for function symbols too.
|
|
|
|
|
|
(ctf_symbol_next): New, iterate over symbols with types (without
|
|
|
|
|
|
sorting).
|
|
|
|
|
|
(ctf_lookup_idx_name): New, bsearch for symbol names in indexes.
|
|
|
|
|
|
(ctf_try_lookup_indexed): New, attempt an indexed lookup.
|
|
|
|
|
|
(ctf_func_info): Reimplement in terms of ctf_lookup_by_symbol.
|
|
|
|
|
|
(ctf_func_args): Likewise.
|
|
|
|
|
|
(ctf_get_dict): Move...
|
|
|
|
|
|
* ctf-types.c (ctf_get_dict): ... here.
|
|
|
|
|
|
* ctf-util.c (ctf_sym_to_elf64): Re-express as...
|
|
|
|
|
|
(ctf_elf64_to_link_sym): ... this. Add new st_symidx field, and
|
|
|
|
|
|
st_nameidx_set (always 0, so st_nameidx can be ignored). Look in
|
|
|
|
|
|
the ELF strtab for names.
|
|
|
|
|
|
(ctf_elf32_to_link_sym): Likewise, for Elf32_Sym.
|
|
|
|
|
|
(ctf_next_destroy): Destroy ctf_next_t.u.ctn_next if need be.
|
|
|
|
|
|
* libctf.ver: Add ctf_symbol_next, ctf_add_objt_sym and
|
|
|
|
|
|
ctf_add_func_sym.
|
|
|
|
|
|
|
bfd, include, ld, binutils, libctf: CTF should use the dynstr/sym
This is embarrassing.
The whole point of CTF is that it remains intact even after a binary is
stripped, providing a compact mapping from symbols to types for
everything in the externally-visible interface of an ELF object: it has
connections to the symbol table for that purpose, and to the string
table to avoid duplicating symbol names. So it's a shame that the hooks
I implemented last year served to hook it up to the .symtab and .strtab,
which obviously disappear on strip, leaving any accompanying the CTF
dict containing references to strings (and, soon, symbols) which don't
exist any more because their containing strtab has been vaporized. The
original Solaris design used .dynsym and .dynstr (well, actually,
.ldynsym, which has more symbols) which do not disappear. So should we.
Thankfully the work we did before serves as guide rails, and adjusting
things to use the .dynstr and .dynsym was fast and easy. The only
annoyance is that the dynsym is assembled inside elflink.c in a fairly
piecemeal fashion, so that the easiest way to get the symbols out was to
hook in before every call to swap_symbol_out (we also leave in a hook in
front of symbol additions to the .symtab because it seems plausible that
we might want to hook them in future too: for now that hook is unused).
We adjust things so that rather than being offered a whole hash table of
symbols at once, libctf is now given symbols one at a time, with st_name
indexes already resolved and pointing at their final .dynstr offsets:
it's now up to libctf to resolve these to names as needed using the
strtab info we pass it separately.
Some bits might be contentious. The ctf_new_dynstr callback takes an
elf_internal_sym, and this remains an elf_internal_sym right down
through the generic emulation layers into ldelfgen. This is no worse
than the elf_sym_strtab we used to pass down, but in the future when we
gain non-ELF CTF symtab support we might want to lower the
elf_internal_sym to some other representation (perhaps a
ctf_link_symbol) in bfd or in ldlang_ctf_new_dynsym. We rename the
'apply_strsym' hooks to 'acquire_strings' instead, becuse they no longer
have anything to do with symbols.
There are some API changes to pieces of API which are technically public
but actually totally unused by anything and/or unused by anything but ld
so they can change freely: the ctf_link_symbol gains new fields to allow
symbol names to be given as strtab offsets as well as strings, and a
symidx so that the symbol index can be passed in. ctf_link_shuffle_syms
loses its callback parameter: the idea now is that linkers call the new
ctf_link_add_linker_symbol for every symbol in .dynsym, feed in all the
strtab entries with ctf_link_add_strtab, and then a call to
ctf_link_shuffle_syms will apply both and arrange to use them to reorder
the CTF symtab at CTF serialization time (which is coming in the next
commit).
Inside libctf we have a new preamble flag CTF_F_DYNSTR which is always
set in v3-format CTF dicts from this commit forwards: CTF dicts without
this flag are associated with .strtab like they used to be, so that old
dicts' external strings don't turn to garbage when loaded by new libctf.
Dicts with this flag are associated with .dynstr and .dynsym instead.
(The flag is not the next in sequence because this commit was written
quite late: the missing flags will be filled in by the next commit.)
Tests forthcoming in a later commit in this series.
bfd/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* elflink.c (elf_finalize_dynstr): Call examine_strtab after
dynstr finalization.
(elf_link_swap_symbols_out): Don't call it here. Call
ctf_new_symbol before swap_symbol_out.
(elf_link_output_extsym): Call ctf_new_dynsym before
swap_symbol_out.
(bfd_elf_final_link): Likewise.
* elf.c (swap_out_syms): Pass in bfd_link_info. Call
ctf_new_symbol before swap_symbol_out.
(_bfd_elf_compute_section_file_positions): Adjust.
binutils/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* readelf.c (dump_section_as_ctf): Use .dynsym and .dynstr, not
.symtab and .strtab.
include/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* bfdlink.h (struct elf_sym_strtab): Replace with...
(struct elf_internal_sym): ... this.
(struct bfd_link_callbacks) <examine_strtab>: Take only a
symstrtab argument.
<ctf_new_symbol>: New.
<ctf_new_dynsym>: Likewise.
* ctf-api.h (struct ctf_link_sym) <st_symidx>: New.
<st_nameidx>: Likewise.
<st_nameidx_set>: Likewise.
(ctf_link_iter_symbol_f): Removed.
(ctf_link_shuffle_syms): Remove most parameters, just takes a
ctf_dict_t now.
(ctf_link_add_linker_symbol): New, split from
ctf_link_shuffle_syms.
* ctf.h (CTF_F_DYNSTR): New.
(CTF_F_MAX): Adjust.
ld/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ldelfgen.c (struct ctf_strsym_iter_cb_arg): Rename to...
(struct ctf_strtab_iter_cb_arg): ... this, changing fields:
<syms>: Remove.
<symcount>: Remove.
<symstrtab>: Rename to...
<strtab>: ... this.
(ldelf_ctf_strtab_iter_cb): Adjust.
(ldelf_ctf_symbols_iter_cb): Remove.
(ldelf_new_dynsym_for_ctf): New, tell libctf about a single
symbol.
(ldelf_examine_strtab_for_ctf): Rename to...
(ldelf_acquire_strings_for_ctf): ... this, only doing the strtab
portion and not symbols.
* ldelfgen.h: Adjust declarations accordingly.
* ldemul.c (ldemul_examine_strtab_for_ctf): Rename to...
(ldemul_acquire_strings_for_ctf): ... this.
(ldemul_new_dynsym_for_ctf): New.
* ldemul.h: Adjust declarations accordingly.
* ldlang.c (ldlang_ctf_apply_strsym): Rename to...
(ldlang_ctf_acquire_strings): ... this.
(ldlang_ctf_new_dynsym): New.
(lang_write_ctf): Call ldemul_new_dynsym_for_ctf with NULL to do
the actual symbol shuffle.
* ldlang.h (struct elf_strtab_hash): Adjust accordingly.
* ldmain.c (bfd_link_callbacks): Wire up new/renamed callbacks.
libctf/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-link.c (ctf_link_shuffle_syms): Adjust.
(ctf_link_add_linker_symbol): New, unimplemented stub.
* libctf.ver: Add it.
* ctf-create.c (ctf_serialize): Set CTF_F_DYNSTR on newly-serialized
dicts.
* ctf-open-bfd.c (ctf_bfdopen_ctfsect): Check for the flag: open the
symtab/strtab if not present, dynsym/dynstr otherwise.
* ctf-archive.c (ctf_arc_bufpreamble): New, get the preamble from
some arbitrary member of a CTF archive.
* ctf-impl.h (ctf_arc_bufpreamble): Declare it.
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c (ctf_link_shuffle_syms): Adjust.
|
|
|
|
|
|
(ctf_link_add_linker_symbol): New, unimplemented stub.
|
|
|
|
|
|
* libctf.ver: Add it.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Set CTF_F_DYNSTR on newly-serialized
|
|
|
|
|
|
dicts.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_bfdopen_ctfsect): Check for the flag: open the
|
|
|
|
|
|
symtab/strtab if not present, dynsym/dynstr otherwise.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_bufpreamble): New, get the preamble from
|
|
|
|
|
|
some arbitrary member of a CTF archive.
|
|
|
|
|
|
* ctf-impl.h (ctf_arc_bufpreamble): Declare it.
|
|
|
|
|
|
|
libctf, include, binutils, gdb: rename CTF-opening functions
The functions that return ctf_dict_t's given a ctf_archive_t and a name
are very clumsily named. It sounds like they return *archives*, not
dictionaries, and the names are very long and clunky. Why do we
have a ctf_arc_open_by_name when it opens a dictionary, not an archive,
and when there is no way to open a dictionary in any other way? The
answer is purely internal: the function is located in ctf-archive.c,
and everything in there was called ctf_arc_*, and there is another
way to open a dict (by offset in the archive), that is internal to
ctf-archive.c and that nothing else can call.
This is clearly bad naming. The internal organization of the source tree
should not dictate public API names!
So rename things (keeping the old, bad names for compatibility), and
adjust all users. You now open a dict using ctf_dict_open, and
open it giving ELF sections via ctf_dict_open_sections.
binutils/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* objdump.c (dump_ctf): Use ctf_dict_open, not
ctf_arc_open_by_name.
* readelf.c (dump_section_as_ctf): Likewise.
gdb/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctfread.c (elfctf_build_psymtabs): Use ctf_dict_open, not
ctf_arc_open_by_name.
include/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ctf_arc_open_by_name): Rename to...
(ctf_dict_open): ... this, keeping compatibility function.
(ctf_arc_open_by_name_sections): Rename to...
(ctf_dict_open_sections): ... this, keeping compatibility function.
libctf/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-archive.c (ctf_arc_open_by_offset): Rename to...
(ctf_dict_open_by_offset): ... this. Adjust callers.
(ctf_arc_open_by_name_internal): Rename to...
(ctf_dict_open_internal): ... this. Adjust callers.
(ctf_arc_open_by_name_sections): Rename to...
(ctf_dict_open_sections): ... this, keeping compatibility function.
(ctf_arc_open_by_name): Rename to...
(ctf_dict_open): ... this, keeping compatibility function.
* libctf.ver: New functions added.
* ctf-link.c (ctf_link_one_input_archive): Adjusted accordingly.
(ctf_link_deduplicating_open_inputs): Likewise.
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_open_by_offset): Rename to...
|
|
|
|
|
|
(ctf_dict_open_by_offset): ... this. Adjust callers.
|
|
|
|
|
|
(ctf_arc_open_by_name_internal): Rename to...
|
|
|
|
|
|
(ctf_dict_open_internal): ... this. Adjust callers.
|
|
|
|
|
|
(ctf_arc_open_by_name_sections): Rename to...
|
|
|
|
|
|
(ctf_dict_open_sections): ... this, keeping compatibility function.
|
|
|
|
|
|
(ctf_arc_open_by_name): Rename to...
|
|
|
|
|
|
(ctf_dict_open): ... this, keeping compatibility function.
|
|
|
|
|
|
* libctf.ver: New functions added.
|
|
|
|
|
|
* ctf-link.c (ctf_link_one_input_archive): Adjusted accordingly.
|
|
|
|
|
|
(ctf_link_deduplicating_open_inputs): Likewise.
|
|
|
|
|
|
|
libctf, include, binutils, gdb, ld: rename ctf_file_t to ctf_dict_t
The naming of the ctf_file_t type in libctf is a historical curiosity.
Back in the Solaris days, CTF dictionaries were originally generated as
a separate file and then (sometimes) merged into objects: hence the
datatype was named ctf_file_t, and known as a "CTF file". Nowadays, raw
CTF is essentially never written to a file on its own, and the datatype
changed name to a "CTF dictionary" years ago. So the term "CTF file"
refers to something that is never a file! This is at best confusing.
The type has also historically been known as a 'CTF container", which is
even more confusing now that we have CTF archives which are *also* a
sort of container (they contain CTF dictionaries), but which are never
referred to as containers in the source code.
So fix this by completing the renaming, renaming ctf_file_t to
ctf_dict_t throughout, and renaming those few functions that refer to
CTF files by name (keeping compatibility aliases) to refer to dicts
instead. Old users who still refer to ctf_file_t will see (harmless)
pointer-compatibility warnings at compile time, but the ABI is unchanged
(since C doesn't mangle names, and ctf_file_t was always an opaque type)
and things will still compile fine as long as -Werror is not specified.
All references to CTF containers and CTF files in the source code are
fixed to refer to CTF dicts instead.
Further (smaller) renamings of annoyingly-named functions to come, as
part of the process of souping up queries across whole archives at once
(needed for the function info and data object sections).
binutils/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* objdump.c (dump_ctf_errs): Rename ctf_file_t to ctf_dict_t.
(dump_ctf_archive_member): Likewise.
(dump_ctf): Likewise. Use ctf_dict_close, not ctf_file_close.
* readelf.c (dump_ctf_errs): Rename ctf_file_t to ctf_dict_t.
(dump_ctf_archive_member): Likewise.
(dump_section_as_ctf): Likewise. Use ctf_dict_close, not
ctf_file_close.
gdb/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctfread.c: Change uses of ctf_file_t to ctf_dict_t.
(ctf_fp_info::~ctf_fp_info): Call ctf_dict_close, not ctf_file_close.
include/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ctf_file_t): Rename to...
(ctf_dict_t): ... this. Keep ctf_file_t around for compatibility.
(struct ctf_file): Likewise rename to...
(struct ctf_dict): ... this.
(ctf_file_close): Rename to...
(ctf_dict_close): ... this, keeping compatibility function.
(ctf_parent_file): Rename to...
(ctf_parent_dict): ... this, keeping compatibility function.
All callers adjusted.
* ctf.h: Rename references to ctf_file_t to ctf_dict_t.
(struct ctf_archive) <ctfa_nfiles>: Rename to...
<ctfa_ndicts>: ... this.
ld/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ldlang.c (ctf_output): This is a ctf_dict_t now.
(lang_ctf_errs_warnings): Rename ctf_file_t to ctf_dict_t.
(ldlang_open_ctf): Adjust comment.
(lang_merge_ctf): Use ctf_dict_close, not ctf_file_close.
* ldelfgen.h (ldelf_examine_strtab_for_ctf): Rename ctf_file_t to
ctf_dict_t. Change opaque declaration accordingly.
* ldelfgen.c (ldelf_examine_strtab_for_ctf): Adjust.
* ldemul.h (examine_strtab_for_ctf): Likewise.
(ldemul_examine_strtab_for_ctf): Likewise.
* ldeuml.c (ldemul_examine_strtab_for_ctf): Likewise.
libctf/ChangeLog
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
* ctf-impl.h: Rename ctf_file_t to ctf_dict_t: all declarations
adjusted.
(ctf_fileops): Rename to...
(ctf_dictops): ... this.
(ctf_dedup_t) <cd_id_to_file_t>: Rename to...
<cd_id_to_dict_t>: ... this.
(ctf_file_t): Fix outdated comment.
<ctf_fileops>: Rename to...
<ctf_dictops>: ... this.
(struct ctf_archive_internal) <ctfi_file>: Rename to...
<ctfi_dict>: ... this.
* ctf-archive.c: Rename ctf_file_t to ctf_dict_t.
Rename ctf_archive.ctfa_nfiles to ctfa_ndicts.
Rename ctf_file_close to ctf_dict_close. All users adjusted.
* ctf-create.c: Likewise. Refer to CTF dicts, not CTF containers.
(ctf_bundle_t) <ctb_file>: Rename to...
<ctb_dict): ... this.
* ctf-decl.c: Rename ctf_file_t to ctf_dict_t.
* ctf-dedup.c: Likewise. Rename ctf_file_close to
ctf_dict_close. Refer to CTF dicts, not CTF containers.
* ctf-dump.c: Likewise.
* ctf-error.c: Likewise.
* ctf-hash.c: Likewise.
* ctf-inlines.h: Likewise.
* ctf-labels.c: Likewise.
* ctf-link.c: Likewise.
* ctf-lookup.c: Likewise.
* ctf-open-bfd.c: Likewise.
* ctf-string.c: Likewise.
* ctf-subr.c: Likewise.
* ctf-types.c: Likewise.
* ctf-util.c: Likewise.
* ctf-open.c: Likewise.
(ctf_file_close): Rename to...
(ctf_dict_close): ...this.
(ctf_file_close): New trivial wrapper around ctf_dict_close, for
compatibility.
(ctf_parent_file): Rename to...
(ctf_parent_dict): ... this.
(ctf_parent_file): New trivial wrapper around ctf_parent_dict, for
compatibility.
* libctf.ver: Add ctf_dict_close and ctf_parent_dict.
2020-11-20 21:34:04 +08:00
|
|
|
|
2020-11-20 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h: Rename ctf_file_t to ctf_dict_t: all declarations
|
|
|
|
|
|
adjusted.
|
|
|
|
|
|
(ctf_fileops): Rename to...
|
|
|
|
|
|
(ctf_dictops): ... this.
|
|
|
|
|
|
(ctf_dedup_t) <cd_id_to_file_t>: Rename to...
|
|
|
|
|
|
<cd_id_to_dict_t>: ... this.
|
|
|
|
|
|
(ctf_file_t): Fix outdated comment.
|
|
|
|
|
|
<ctf_fileops>: Rename to...
|
|
|
|
|
|
<ctf_dictops>: ... this.
|
|
|
|
|
|
(struct ctf_archive_internal) <ctfi_file>: Rename to...
|
|
|
|
|
|
<ctfi_dict>: ... this.
|
|
|
|
|
|
* ctf-archive.c: Rename ctf_file_t to ctf_dict_t.
|
|
|
|
|
|
Rename ctf_archive.ctfa_nfiles to ctfa_ndicts.
|
|
|
|
|
|
Rename ctf_file_close to ctf_dict_close. All users adjusted.
|
|
|
|
|
|
* ctf-create.c: Likewise. Refer to CTF dicts, not CTF containers.
|
|
|
|
|
|
(ctf_bundle_t) <ctb_file>: Rename to...
|
|
|
|
|
|
<ctb_dict): ... this.
|
|
|
|
|
|
* ctf-decl.c: Rename ctf_file_t to ctf_dict_t.
|
|
|
|
|
|
* ctf-dedup.c: Likewise. Rename ctf_file_close to
|
|
|
|
|
|
ctf_dict_close. Refer to CTF dicts, not CTF containers.
|
|
|
|
|
|
* ctf-dump.c: Likewise.
|
|
|
|
|
|
* ctf-error.c: Likewise.
|
|
|
|
|
|
* ctf-hash.c: Likewise.
|
|
|
|
|
|
* ctf-inlines.h: Likewise.
|
|
|
|
|
|
* ctf-labels.c: Likewise.
|
|
|
|
|
|
* ctf-link.c: Likewise.
|
|
|
|
|
|
* ctf-lookup.c: Likewise.
|
|
|
|
|
|
* ctf-open-bfd.c: Likewise.
|
|
|
|
|
|
* ctf-string.c: Likewise.
|
|
|
|
|
|
* ctf-subr.c: Likewise.
|
|
|
|
|
|
* ctf-types.c: Likewise.
|
|
|
|
|
|
* ctf-util.c: Likewise.
|
|
|
|
|
|
* ctf-open.c: Likewise.
|
|
|
|
|
|
(ctf_file_close): Rename to...
|
|
|
|
|
|
(ctf_dict_close): ...this.
|
|
|
|
|
|
(ctf_file_close): New trivial wrapper around ctf_dict_close, for
|
|
|
|
|
|
compatibility.
|
|
|
|
|
|
(ctf_parent_file): Rename to...
|
|
|
|
|
|
(ctf_parent_dict): ... this.
|
|
|
|
|
|
(ctf_parent_file): New trivial wrapper around ctf_parent_dict, for
|
|
|
|
|
|
compatibility.
|
|
|
|
|
|
* libctf.ver: Add ctf_dict_close and ctf_parent_dict.
|
|
|
|
|
|
|
2020-10-21 22:54:17 +08:00
|
|
|
|
2020-10-21 Tom Tromey <tromey@adacore.com>
|
|
|
|
|
|
|
|
|
|
|
|
* mkerrors.sed: Remove.
|
|
|
|
|
|
* ctf-error.c (_CTF_FIRST): New define.
|
|
|
|
|
|
(_CTF_ITEM): Define this, not _CTF_STR.
|
|
|
|
|
|
(_ctf_errlist, _ctf_erridx): Use _CTF_ERRORS.
|
|
|
|
|
|
(ERRSTRFIELD): Rewrite.
|
|
|
|
|
|
(ERRSTRFIELD1): Remove.
|
|
|
|
|
|
* Makefile.in: Rebuild.
|
|
|
|
|
|
* Makefile.am (BUILT_SOURCES): Remove.
|
|
|
|
|
|
(ctf-error.h): Remove.
|
|
|
|
|
|
|
libctf, binutils, include, ld: gettextize and improve error handling
This commit follows on from the earlier commit "libctf, ld, binutils:
add textual error/warning reporting for libctf" and converts every error
in libctf that was reported using ctf_dprintf to use ctf_err_warn
instead, gettextizing them in the process, using N_() where necessary to
avoid doing gettext calls unless an error message is actually generated,
and rephrasing some error messages for ease of translation.
This requires a slight change in the ctf_errwarning_next API: this API
is public but has not been in a release yet, so can still change freely.
The problem is that many errors are emitted at open time (whether
opening of a CTF dict, or opening of a CTF archive): the former of these
throws away its incompletely-initialized ctf_file_t rather than return
it, and the latter has no ctf_file_t at all. So errors and warnings
emitted at open time cannot be stored in the ctf_file_t, and have to go
elsewhere.
We put them in a static local in ctf-subr.c (which is not very
thread-safe: a later commit will improve things here): ctf_err_warn with
a NULL fp adds to this list, and the public interface
ctf_errwarning_next with a NULL fp retrieves from it.
We need a slight exception from the usual iterator rules in this case:
with a NULL fp, there is nowhere to store the ECTF_NEXT_END "error"
which signifies the end of iteration, so we add a new err parameter to
ctf_errwarning_next which is used to report such iteration-related
errors. (If an fp is provided -- i.e., if not reporting open errors --
this is optional, but even if it's optional it's still an API change.
This is actually useful from a usability POV as well, since
ctf_errwarning_next is usually called when there's been an error, so
overwriting the error code with ECTF_NEXT_END is not very helpful!
So, unusually, ctf_errwarning_next now uses the passed fp for its
error code *only* if no errp pointer is passed in, and leaves it
untouched otherwise.)
ld, objdump and readelf are adapted to call ctf_errwarning_next with a
NULL fp to report open errors where appropriate.
The ctf_err_warn API also has to change, gaining a new error-number
parameter which is used to add the error message corresponding to that
error number into the debug stream when LIBCTF_DEBUG is enabled:
changing this API is easy at this point since we are already touching
all existing calls to gettextize them. We need this because the debug
stream should contain the errno's message, but the error reported in the
error/warning stream should *not*, because the caller will probably
report it themselves at failure time regardless, and reporting it in
every error message that leads up to it leads to a ridiculous chattering
on failure, which is likely to end up as ridiculous chattering on stderr
(trimmed a bit):
CTF error: `ld/testsuite/ld-ctf/A.c (0): lookup failure for type 3: flags 1: The parent CTF dictionary is unavailable'
CTF error: `ld/testsuite/ld-ctf/A.c (0): struct/union member type hashing error during type hashing for type 80000001, kind 6: The parent CTF dictionary is unavailable'
CTF error: `deduplicating link variable emission failed for ld/testsuite/ld-ctf/A.c: The parent CTF dictionary is unavailable'
ld/.libs/lt-ld-new: warning: CTF linking failed; output will have no CTF section: `The parent CTF dictionary is unavailable'
We only need to be told that the parent CTF dictionary is unavailable
*once*, not over and over again!
errmsgs are still emitted on warning generation, because warnings do not
usually lead to a failure propagated up to the caller and reported
there.
Debug-stream messages are not translated. If translation is turned on,
there will be a mixture of English and translated messages in the debug
stream, but rather that than burden the translators with debug-only
output.
binutils/ChangeLog
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
* objdump.c (dump_ctf_archive_member): Move error-
reporting...
(dump_ctf_errs): ... into this separate function.
(dump_ctf): Call it on open errors.
* readelf.c (dump_ctf_archive_member): Move error-
reporting...
(dump_ctf_errs): ... into this separate function. Support
calls with NULL fp. Adjust for new err parameter to
ctf_errwarning_next.
(dump_section_as_ctf): Call it on open errors.
include/ChangeLog
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ctf_errwarning_next): New err parameter.
ld/ChangeLog
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
* ldlang.c (lang_ctf_errs_warnings): Support calls with NULL fp.
Adjust for new err parameter to ctf_errwarning_next. Only
check for assertion failures when fp is non-NULL.
(ldlang_open_ctf): Call it on open errors.
* testsuite/ld-ctf/ctf.exp: Always use the C locale to avoid
breaking the diags tests.
libctf/ChangeLog
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
* ctf-subr.c (open_errors): New list.
(ctf_err_warn): Calls with NULL fp append to open_errors. Add err
parameter, and use it to decorate the debug stream with errmsgs.
(ctf_err_warn_to_open): Splice errors from a CTF dict into the
open_errors.
(ctf_errwarning_next): Calls with NULL fp report from open_errors.
New err param to report iteration errors (including end-of-iteration)
when fp is NULL.
(ctf_assert_fail_internal): Adjust ctf_err_warn call for new err
parameter: gettextize.
* ctf-impl.h (ctfo_get_vbytes): Add ctf_file_t parameter.
(LCTF_VBYTES): Adjust.
(ctf_err_warn_to_open): New.
(ctf_err_warn): Adjust.
(ctf_bundle): Used in only one place: move...
* ctf-create.c: ... here.
(enumcmp): Use ctf_err_warn, not ctf_dprintf, passing the err number
down as needed. Don't emit the errmsg. Gettextize.
(membcmp): Likewise.
(ctf_add_type_internal): Likewise.
(ctf_write_mem): Likewise.
(ctf_compress_write): Likewise. Report errors writing the header or
body.
(ctf_write): Likewise.
* ctf-archive.c (ctf_arc_write_fd): Use ctf_err_warn, not
ctf_dprintf, and gettextize, as above.
(ctf_arc_write): Likewise.
(ctf_arc_bufopen): Likewise.
(ctf_arc_open_internal): Likewise.
* ctf-labels.c (ctf_label_iter): Likewise.
* ctf-open-bfd.c (ctf_bfdclose): Likewise.
(ctf_bfdopen): Likewise.
(ctf_bfdopen_ctfsect): Likewise.
(ctf_fdopen): Likewise.
* ctf-string.c (ctf_str_write_strtab): Likewise.
* ctf-types.c (ctf_type_resolve): Likewise.
* ctf-open.c (get_vbytes_common): Likewise. Pass down the ctf dict.
(get_vbytes_v1): Pass down the ctf dict.
(get_vbytes_v2): Likewise.
(flip_ctf): Likewise.
(flip_types): Likewise. Use ctf_err_warn, not ctf_dprintf, and
gettextize, as above.
(upgrade_types_v1): Adjust calls.
(init_types): Use ctf_err_warn, not ctf_dprintf, as above.
(ctf_bufopen_internal): Likewise. Adjust calls. Transplant errors
emitted into individual dicts into the open errors if this turns
out to be a failed open in the end.
* ctf-dump.c (ctf_dump_format_type): Adjust ctf_err_warn for new err
argument. Gettextize. Don't emit the errmsg.
(ctf_dump_funcs): Likewise. Collapse err label into its only case.
(ctf_dump_type): Likewise.
* ctf-link.c (ctf_create_per_cu): Adjust ctf_err_warn for new err
argument. Gettextize. Don't emit the errmsg.
(ctf_link_one_type): Likewise.
(ctf_link_lazy_open): Likewise.
(ctf_link_one_input_archive): Likewise.
(ctf_link_deduplicating_count_inputs): Likewise.
(ctf_link_deduplicating_open_inputs): Likewise.
(ctf_link_deduplicating_close_inputs): Likewise.
(ctf_link_deduplicating): Likewise.
(ctf_link): Likewise.
(ctf_link_deduplicating_per_cu): Likewise. Add some missed
ctf_set_errnos to obscure error cases.
* ctf-dedup.c (ctf_dedup_rhash_type): Adjust ctf_err_warn for new
err argument. Gettextize. Don't emit the errmsg.
(ctf_dedup_populate_mappings): Likewise.
(ctf_dedup_detect_name_ambiguity): Likewise.
(ctf_dedup_init): Likewise.
(ctf_dedup_multiple_input_dicts): Likewise.
(ctf_dedup_conflictify_unshared): Likewise.
(ctf_dedup): Likewise.
(ctf_dedup_rwalk_one_output_mapping): Likewise.
(ctf_dedup_id_to_target): Likewise.
(ctf_dedup_emit_type): Likewise.
(ctf_dedup_emit_struct_members): Likewise.
(ctf_dedup_populate_type_mapping): Likewise.
(ctf_dedup_populate_type_mappings): Likewise.
(ctf_dedup_emit): Likewise.
(ctf_dedup_hash_type): Likewise. Fix a bit of messed-up error
status setting.
(ctf_dedup_rwalk_one_output_mapping): Likewise. Don't hide
unknown-type-kind messages (which signify file corruption).
2020-07-27 23:45:15 +08:00
|
|
|
|
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-subr.c (open_errors): New list.
|
|
|
|
|
|
(ctf_err_warn): Calls with NULL fp append to open_errors. Add err
|
|
|
|
|
|
parameter, and use it to decorate the debug stream with errmsgs.
|
|
|
|
|
|
(ctf_err_warn_to_open): Splice errors from a CTF dict into the
|
|
|
|
|
|
open_errors.
|
|
|
|
|
|
(ctf_errwarning_next): Calls with NULL fp report from open_errors.
|
|
|
|
|
|
New err param to report iteration errors (including end-of-iteration)
|
|
|
|
|
|
when fp is NULL.
|
|
|
|
|
|
(ctf_assert_fail_internal): Adjust ctf_err_warn call for new err
|
|
|
|
|
|
parameter: gettextize.
|
|
|
|
|
|
* ctf-impl.h (ctfo_get_vbytes): Add ctf_file_t parameter.
|
|
|
|
|
|
(LCTF_VBYTES): Adjust.
|
|
|
|
|
|
(ctf_err_warn_to_open): New.
|
|
|
|
|
|
(ctf_err_warn): Adjust.
|
|
|
|
|
|
(ctf_bundle): Used in only one place: move...
|
|
|
|
|
|
* ctf-create.c: ... here.
|
|
|
|
|
|
(enumcmp): Use ctf_err_warn, not ctf_dprintf, passing the err number
|
|
|
|
|
|
down as needed. Don't emit the errmsg. Gettextize.
|
|
|
|
|
|
(membcmp): Likewise.
|
|
|
|
|
|
(ctf_add_type_internal): Likewise.
|
|
|
|
|
|
(ctf_write_mem): Likewise.
|
|
|
|
|
|
(ctf_compress_write): Likewise. Report errors writing the header or
|
|
|
|
|
|
body.
|
|
|
|
|
|
(ctf_write): Likewise.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_write_fd): Use ctf_err_warn, not
|
|
|
|
|
|
ctf_dprintf, and gettextize, as above.
|
|
|
|
|
|
(ctf_arc_write): Likewise.
|
|
|
|
|
|
(ctf_arc_bufopen): Likewise.
|
|
|
|
|
|
(ctf_arc_open_internal): Likewise.
|
|
|
|
|
|
* ctf-labels.c (ctf_label_iter): Likewise.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_bfdclose): Likewise.
|
|
|
|
|
|
(ctf_bfdopen): Likewise.
|
|
|
|
|
|
(ctf_bfdopen_ctfsect): Likewise.
|
|
|
|
|
|
(ctf_fdopen): Likewise.
|
|
|
|
|
|
* ctf-string.c (ctf_str_write_strtab): Likewise.
|
|
|
|
|
|
* ctf-types.c (ctf_type_resolve): Likewise.
|
|
|
|
|
|
* ctf-open.c (get_vbytes_common): Likewise. Pass down the ctf dict.
|
|
|
|
|
|
(get_vbytes_v1): Pass down the ctf dict.
|
|
|
|
|
|
(get_vbytes_v2): Likewise.
|
|
|
|
|
|
(flip_ctf): Likewise.
|
|
|
|
|
|
(flip_types): Likewise. Use ctf_err_warn, not ctf_dprintf, and
|
|
|
|
|
|
gettextize, as above.
|
|
|
|
|
|
(upgrade_types_v1): Adjust calls.
|
|
|
|
|
|
(init_types): Use ctf_err_warn, not ctf_dprintf, as above.
|
|
|
|
|
|
(ctf_bufopen_internal): Likewise. Adjust calls. Transplant errors
|
|
|
|
|
|
emitted into individual dicts into the open errors if this turns
|
|
|
|
|
|
out to be a failed open in the end.
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_format_type): Adjust ctf_err_warn for new err
|
|
|
|
|
|
argument. Gettextize. Don't emit the errmsg.
|
|
|
|
|
|
(ctf_dump_funcs): Likewise. Collapse err label into its only case.
|
|
|
|
|
|
(ctf_dump_type): Likewise.
|
|
|
|
|
|
* ctf-link.c (ctf_create_per_cu): Adjust ctf_err_warn for new err
|
|
|
|
|
|
argument. Gettextize. Don't emit the errmsg.
|
|
|
|
|
|
(ctf_link_one_type): Likewise.
|
|
|
|
|
|
(ctf_link_lazy_open): Likewise.
|
|
|
|
|
|
(ctf_link_one_input_archive): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_count_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_open_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_close_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating): Likewise.
|
|
|
|
|
|
(ctf_link): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_per_cu): Likewise. Add some missed
|
|
|
|
|
|
ctf_set_errnos to obscure error cases.
|
|
|
|
|
|
* ctf-dedup.c (ctf_dedup_rhash_type): Adjust ctf_err_warn for new
|
|
|
|
|
|
err argument. Gettextize. Don't emit the errmsg.
|
|
|
|
|
|
(ctf_dedup_populate_mappings): Likewise.
|
|
|
|
|
|
(ctf_dedup_detect_name_ambiguity): Likewise.
|
|
|
|
|
|
(ctf_dedup_init): Likewise.
|
|
|
|
|
|
(ctf_dedup_multiple_input_dicts): Likewise.
|
|
|
|
|
|
(ctf_dedup_conflictify_unshared): Likewise.
|
|
|
|
|
|
(ctf_dedup): Likewise.
|
|
|
|
|
|
(ctf_dedup_rwalk_one_output_mapping): Likewise.
|
|
|
|
|
|
(ctf_dedup_id_to_target): Likewise.
|
|
|
|
|
|
(ctf_dedup_emit_type): Likewise.
|
|
|
|
|
|
(ctf_dedup_emit_struct_members): Likewise.
|
|
|
|
|
|
(ctf_dedup_populate_type_mapping): Likewise.
|
|
|
|
|
|
(ctf_dedup_populate_type_mappings): Likewise.
|
|
|
|
|
|
(ctf_dedup_emit): Likewise.
|
|
|
|
|
|
(ctf_dedup_hash_type): Likewise. Fix a bit of messed-up error
|
|
|
|
|
|
status setting.
|
|
|
|
|
|
(ctf_dedup_rwalk_one_output_mapping): Likewise. Don't hide
|
|
|
|
|
|
unknown-type-kind messages (which signify file corruption).
|
|
|
|
|
|
|
2020-07-31 00:43:12 +08:00
|
|
|
|
2020-08-27 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.ac: Adjust package name to simply 'libctf': arbitrarily
|
|
|
|
|
|
declare this to be version 1.2.0.
|
|
|
|
|
|
* Makefile.am (AM_CPPFLAGS): Add @INCINTL@.
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* configure: Regenerated.
|
|
|
|
|
|
* ctf-intl.h: New file, lightly modified from opcodes/opintl.h.
|
|
|
|
|
|
* ctf-impl.h: Include it.
|
|
|
|
|
|
* ctf-error.r (_ctf_errlist_t): Mark strings as noop-translatable.
|
|
|
|
|
|
(ctf_errmsg): Actually translate them.
|
|
|
|
|
|
|
2020-07-27 07:06:02 +08:00
|
|
|
|
2020-07-26 Eli Zaretskii <eliz@gnu.org>
|
|
|
|
|
|
|
|
|
|
|
|
PR binutils/25155:
|
|
|
|
|
|
* ctf-create.c (EOVERFLOW): If not defined by system header,
|
|
|
|
|
|
redirect to ERANGE as a poor man's substitute.
|
|
|
|
|
|
* ctf-subr.c (ENOTSUP): If not defined, use ENOSYS instead.
|
|
|
|
|
|
|
2020-07-21 22:38:08 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_dtd_insert): Add uintptr_t casts.
|
|
|
|
|
|
(ctf_dtd_delete): Likewise.
|
|
|
|
|
|
(ctf_dtd_lookup): Likewise.
|
|
|
|
|
|
(ctf_rollback): Likewise.
|
|
|
|
|
|
* ctf-hash.c (ctf_hash_lookup_type): Likewise.
|
|
|
|
|
|
* ctf-types.c (ctf_lookup_by_rawhash): Likewise.
|
|
|
|
|
|
|
2020-07-13 23:05:15 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-lookup.c (ctf_lookup_by_name): Adjust.
|
|
|
|
|
|
|
2020-07-02 03:10:17 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_bufopen): Endian-swap the archive magic
|
|
|
|
|
|
number if needed.
|
|
|
|
|
|
|
libctf, link: tie in the deduplicating linker
This fairly intricate commit connects up the CTF linker machinery (which
operates in terms of ctf_archive_t's on ctf_link_inputs ->
ctf_link_outputs) to the deduplicator (which operates in terms of arrays
of ctf_file_t's, all the archives exploded).
The nondeduplicating linker is retained, but is not called unless the
CTF_LINK_NONDEDUP flag is passed in (which ld never does), or the
environment variable LD_NO_CTF_DEDUP is set. Eventually, once we have
confidence in the much-more-complex deduplicating linker, I hope the
nondeduplicating linker can be removed.
In brief, what this does is traverses each input archive in
ctf_link_inputs, opening every member (if not already open) and tying
child dicts to their parents, shoving them into an array and
constructing a corresponding parents array that tells the deduplicator
which dict is the parent of which child. We then call ctf_dedup and
ctf_dedup_emit with that array of inputs, taking the outputs that result
and putting them into ctf_link_outputs where the rest of the CTF linker
expects to find them, then linking in the variables just as is done by
the nondeduplicating linker.
It also implements much of the CU-mapping side of things. The problem
CU-mapping introduces is that if you map many input CUs into one output,
this is saying that you want many translation units to produce at most
one child dict if conflicting types are found in any of them. This
means you can suddenly have multiple distinct types with the same name
in the same dict, which libctf cannot really represent because it's not
something you can do with C translation units.
The deduplicator machinery already committed does as best it can with
these, hiding types with conflicting names rather than making child
dicts out of them: but we still need to call it. This is done similarly
to the main link, taking the inputs (one CU output at a time),
deduplicating them, taking the output and making it an input to the
final link. Two (significant) optimizations are done: we share atoms
tables between all these links and the final link (so e.g. all type hash
values are shared, all decorated type names, etc); and any CU-mapped
links with only one input (and no child dicts) doesn't need to do
anything other than renaming the CU: the CU-mapped link phase can be
skipped for it. Put together, large CU-mapped links can save 50% of
their memory usage and about as much time (and the memory usage for
CU-mapped links is significant, because all those output CUs have to
have all their types stored in memory all at once).
include/
* ctf-api.h (CTF_LINK_NONDEDUP): New, turn off the
deduplicator.
libctf/
* ctf-impl.h (ctf_list_splice): New.
* ctf-util.h (ctf_list_splice): Likewise.
* ctf-link.c (link_sort_inputs_cb_arg_t): Likewise.
(ctf_link_sort_inputs): Likewise.
(ctf_link_deduplicating_count_inputs): Likewise.
(ctf_link_deduplicating_open_inputs): Likewise.
(ctf_link_deduplicating_close_inputs): Likewise.
(ctf_link_deduplicating_variables): Likewise.
(ctf_link_deduplicating_per_cu): Likewise.
(ctf_link_deduplicating): Likewise.
(ctf_link): Call it.
2020-06-06 05:57:06 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_list_splice): New.
|
|
|
|
|
|
* ctf-util.h (ctf_list_splice): Likewise.
|
|
|
|
|
|
* ctf-link.c (link_sort_inputs_cb_arg_t): Likewise.
|
|
|
|
|
|
(ctf_link_sort_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_count_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_open_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_close_inputs): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_variables): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating_per_cu): Likewise.
|
|
|
|
|
|
(ctf_link_deduplicating): Likewise.
|
|
|
|
|
|
(ctf_link): Call it.
|
|
|
|
|
|
|
2020-06-06 05:52:41 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c (ctf_link_one_input_archive_member): Check
|
|
|
|
|
|
CTF_LINK_OMIT_VARIABLES_SECTION.
|
|
|
|
|
|
|
2020-06-06 01:35:46 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_type_id_key): New, the key in the
|
|
|
|
|
|
cd_id_to_file_t.
|
|
|
|
|
|
(ctf_dedup): New, core deduplicator state.
|
|
|
|
|
|
(ctf_file_t) <ctf_dedup>: New.
|
|
|
|
|
|
<ctf_dedup_atoms>: New.
|
|
|
|
|
|
<ctf_dedup_atoms_alloc>: New.
|
|
|
|
|
|
(ctf_hash_type_id_key): New prototype.
|
|
|
|
|
|
(ctf_hash_eq_type_id_key): Likewise.
|
|
|
|
|
|
(ctf_dedup_atoms_init): Likewise.
|
|
|
|
|
|
* ctf-hash.c (ctf_hash_eq_type_id_key): New.
|
|
|
|
|
|
(ctf_dedup_atoms_init): Likewise.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Adjusted.
|
|
|
|
|
|
(ctf_add_encoded): No longer static.
|
|
|
|
|
|
(ctf_add_reftype): Likewise.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Destroy the
|
|
|
|
|
|
ctf_dedup_atoms_alloc.
|
|
|
|
|
|
* ctf-dedup.c: New file.
|
|
|
|
|
|
* ctf-decls.h [!HAVE_DECL_STPCPY]: Add prototype.
|
|
|
|
|
|
* configure.ac: Check for stpcpy.
|
|
|
|
|
|
* Makefile.am: Add it.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
* config.h.in: Regenerate.
|
|
|
|
|
|
* configure: Regenerate.
|
|
|
|
|
|
|
2020-06-06 01:38:03 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.ac: Add --enable-libctf-hash-debugging.
|
|
|
|
|
|
* aclocal.m4: Pull in enable.m4, for GCC_ENABLE.
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
* config.h.in: Likewise.
|
|
|
|
|
|
* ctf-impl.h [ENABLE_LIBCTF_HASH_DEBUGGING]
|
|
|
|
|
|
(ctf_assert): Define to assert.
|
|
|
|
|
|
|
2020-06-06 04:10:37 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-sha1.h: New, inline wrappers around sha1_init_ctx and
|
|
|
|
|
|
sha1_process_bytes.
|
|
|
|
|
|
* ctf-impl.h: Include it.
|
|
|
|
|
|
(ctf_sha1_init): New.
|
|
|
|
|
|
(ctf_sha1_add): Likewise.
|
|
|
|
|
|
(ctf_sha1_fini): Likewise.
|
|
|
|
|
|
* ctf-sha1.c: New, non-inline wrapper around sha1_finish_ctx
|
|
|
|
|
|
producing strings.
|
|
|
|
|
|
* Makefile.am: Add file.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
|
2020-06-06 01:15:26 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* libctf.ver (ctf_link_set_variable_filter): Add.
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t) <ctf_link_variable_filter>: New.
|
|
|
|
|
|
<ctf_link_variable_filter_arg>: Likewise.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Adjust.
|
|
|
|
|
|
* ctf-link.c (ctf_link_set_variable_filter): New, set it.
|
|
|
|
|
|
(ctf_link_one_variable): Call it if set.
|
|
|
|
|
|
|
libctf, link: fix spurious conflicts of variables in the variable section
When we link a CTF variable, we check to see if it already exists in the
parent dict first: if it does, and it has a type the same as the type we
would populate it with, we assume we don't need to do anything:
otherwise, we populate it in a per-CU child.
Or that's what we should be doing. Instead, we check if the type is the
same as the type in *source dict*, which is going to be a completely
different value! So we end up concluding all variables are conflicting,
bloating up output possibly quite a lot (variables aren't big in and of
themselves, but each drags around a strtab entry, and CTF dicts in a CTF
archive do not share their strtabs -- one of many problems with CTF
archives as presently constituted.)
Fix trivial: check the right type.
libctf/
* ctf-link.c (ctf_link_one_variable): Check the dst_type for
conflicts, not the source type.
2020-03-11 08:01:41 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c (ctf_link_one_variable): Check the dst_type for
|
|
|
|
|
|
conflicts, not the source type.
|
|
|
|
|
|
|
libctf, link: redo cu-mapping handling
Now a bunch of stuff that doesn't apply to ld or any normal use of
libctf, piled into one commit so that it's easier to ignore.
The cu-mapping machinery associates incoming compilation unit names with
outgoing names of CTF dictionaries that should correspond to them, for
non-gdb CTF consumers that would like to group multiple TUs into a
single child dict if conflicting types are found in it (the existing use
case is one kernel module, one child CTF dict, even if the kernel module
is composed of multiple CUs).
The upcoming deduplicator needs to track not only the mapping from
incoming CU name to outgoing dict name, but the inverse mapping from
outgoing dict name to incoming CU name, so it can work over every CTF
dict we might see in the output and link into it.
So rejig the ctf-link machinery to do that. Simultaneously (because
they are closely associated and were written at the same time), we add a
new CTF_LINK_EMPTY_CU_MAPPINGS flag to ctf_link, which tells the
ctf_link machinery to create empty child dicts for each outgoing CU
mapping even if no CUs that correspond to it exist in the link. This is
a bit (OK, quite a lot) of a waste of space, but some existing consumers
require it. (Nobody else should use it.)
Its value is not consecutive with existing CTF_LINK flag values because
we're about to add more flags that are conceptually closer to the
existing ones than this one is.
include/
* ctf-api.h (CTF_LINK_EMPTY_CU_MAPPINGS): New.
libctf/
* ctf-impl.h (ctf_file_t): Improve comments.
<ctf_link_cu_mapping>: Split into...
<ctf_link_in_cu_mapping>: ... this...
<ctf_link_out_cu_mapping>: ... and this.
* ctf-create.c (ctf_serialize): Adjust.
* ctf-open.c (ctf_file_close): Likewise.
* ctf-link.c (ctf_create_per_cu): Look things up in the
in_cu_mapping instead of the cu_mapping.
(ctf_link_add_cu_mapping): The deduplicating link will define
what happens if many FROMs share a TO.
(ctf_link_add_cu_mapping): Create in_cu_mapping and
out_cu_mapping. Do not create ctf_link_outputs here any more, or
create per-CU dicts here: they are already created when needed.
(ctf_link_one_variable): Log a debug message if we skip a
variable due to its type being concealed in a CU-mapped link.
(This is probably too common a case to make into a warning.)
(ctf_link): Create empty per-CU dicts if requested.
2020-06-06 00:36:16 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t): Improve comments.
|
|
|
|
|
|
<ctf_link_cu_mapping>: Split into...
|
|
|
|
|
|
<ctf_link_in_cu_mapping>: ... this...
|
|
|
|
|
|
<ctf_link_out_cu_mapping>: ... and this.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Adjust.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Likewise.
|
|
|
|
|
|
* ctf-link.c (ctf_create_per_cu): Look things up in the
|
|
|
|
|
|
in_cu_mapping instead of the cu_mapping.
|
|
|
|
|
|
(ctf_link_add_cu_mapping): The deduplicating link will define
|
|
|
|
|
|
what happens if many FROMs share a TO.
|
|
|
|
|
|
(ctf_link_add_cu_mapping): Create in_cu_mapping and
|
|
|
|
|
|
out_cu_mapping. Do not create ctf_link_outputs here any more, or
|
|
|
|
|
|
create per-CU dicts here: they are already created when needed.
|
|
|
|
|
|
(ctf_link_one_variable): Log a debug message if we skip a
|
|
|
|
|
|
variable due to its type being concealed in a CU-mapped link.
|
|
|
|
|
|
(This is probably too common a case to make into a warning.)
|
|
|
|
|
|
(ctf_link): Create empty per-CU dicts if requested.
|
|
|
|
|
|
|
2020-06-05 02:49:36 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c (ctf_link_write): Close the fd.
|
|
|
|
|
|
|
libctf, link: add lazy linking: clean up input members: err/warn cleanup
This rather large and intertwined pile of changes does three things:
First, it transitions from dprintf to ctf_err_warn for things the user might
care about: this one file is the major impetus for the ctf_err_warn
infrastructure, because things like file names are crucial in linker
error messages, and errno values are utterly incapable of
communicating them
Second, it stabilizes the ctf_link APIs: you can now call
ctf_link_add_ctf without a CTF argument (only a NAME), to lazily
ctf_open the file with the given NAME when needed, and close it as soon
as possible, to save memory. This is not an API change because a null
CTF argument was prohibited before now.
Since getting CTF directly from files uses ctf_open, passing in only a
NAME requires use of libctf, not libctf-nobfd. The linker's behaviour
is unchanged, as it still passes in a ctf_archive_t as before.
This also let us fix a leak: we were opening ctf_archives and their
containing ctf_files, then only closing the files and leaving the
archives open.
Third, this commit restructures the ctf_link_in_member argument used by
the CTF linking machinery and adjusts its users accordingly.
We drop two members:
- arcname, which is difficult to construct and then only used in error
messages (that were only dprintf()ed, so never seen!)
- share_mode, since we store the flags passed to ctf_link (including the
share mode) in a new ctf_file_t.ctf_link_flags to help dedup get hold
of it
We rename others whose existing names were fairly dreadful:
- done_main_member -> done_parent, using consistent terminology for .ctf
as the parent of all archive members
- main_input_fp -> in_fp_parent, likewise
- file_name -> in_file_name, likewise
We add one new member, cu_mapped.
Finally, we move the various frees of things like mapping table data to
the top-level ctf_link, since deduplicating links will want to do that
too.
include/
* ctf-api.h (ECTF_NEEDSBFD): New.
(ECTF_NERR): Adjust.
(ctf_link): Rename share_mode arg to flags.
libctf/
* Makefile.am: Set -DNOBFD=1 in libctf-nobfd, and =0 elsewhere.
* Makefile.in: Regenerated.
* ctf-impl.h (ctf_link_input_name): New.
(ctf_file_t) <ctf_link_flags>: New.
* ctf-create.c (ctf_serialize): Adjust accordingly.
* ctf-link.c: Define ctf_open as weak when PIC.
(ctf_arc_close_thunk): Remove unnecessary thunk.
(ctf_file_close_thunk): Likewise.
(ctf_link_input_name): New.
(ctf_link_input_t): New value of the ctf_file_t.ctf_link_input.
(ctf_link_input_close): Adjust accordingly.
(ctf_link_add_ctf_internal): New, split from...
(ctf_link_add_ctf): ... here. Return error if lazy loading of
CTF is not possible. Change to just call...
(ctf_link_add): ... this new function.
(ctf_link_add_cu_mapping): Transition to ctf_err_warn. Drop the
ctf_file_close_thunk.
(ctf_link_in_member_cb_arg_t) <file_name> Rename to...
<in_file_name>: ... this.
<arcname>: Drop.
<share_mode>: Likewise (migrated to ctf_link_flags).
<done_main_member>: Rename to...
<done_parent>: ... this.
<main_input_fp>: Rename to...
<in_fp_parent>: ... this.
<cu_mapped>: New.
(ctf_link_one_type): Adjuwt accordingly. Transition to
ctf_err_warn, removing a TODO.
(ctf_link_one_variable): Note a case too common to warn about.
Report in the debug stream if a cu-mapped link prevents addition
of a conflicting variable.
(ctf_link_one_input_archive_member): Adjust.
(ctf_link_lazy_open): New, open a CTF archive for linking when
needed.
(ctf_link_close_one_input_archive): New, close it again.
(ctf_link_one_input_archive): Adjust for lazy opening, member
renames, and ctf_err_warn transition. Move the
empty_link_type_mapping call to...
(ctf_link): ... here. Adjut for renamings and thunk removal.
Don't spuriously fail if some input contains no CTF data.
(ctf_link_write): ctf_err_warn transition.
* libctf.ver: Remove not-yet-stable comment.
2020-06-05 02:28:52 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* Makefile.am: Set -DNOBFD=1 in libctf-nobfd, and =0 elsewhere.
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* ctf-impl.h (ctf_link_input_name): New.
|
|
|
|
|
|
(ctf_file_t) <ctf_link_flags>: New.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Adjust accordingly.
|
|
|
|
|
|
* ctf-link.c: Define ctf_open as weak when PIC.
|
|
|
|
|
|
(ctf_arc_close_thunk): Remove unnecessary thunk.
|
|
|
|
|
|
(ctf_file_close_thunk): Likewise.
|
|
|
|
|
|
(ctf_link_input_name): New.
|
|
|
|
|
|
(ctf_link_input_t): New value of the ctf_file_t.ctf_link_input.
|
|
|
|
|
|
(ctf_link_input_close): Adjust accordingly.
|
|
|
|
|
|
(ctf_link_add_ctf_internal): New, split from...
|
|
|
|
|
|
(ctf_link_add_ctf): ... here. Return error if lazy loading of
|
|
|
|
|
|
CTF is not possible. Change to just call...
|
|
|
|
|
|
(ctf_link_add): ... this new function.
|
|
|
|
|
|
(ctf_link_add_cu_mapping): Transition to ctf_err_warn. Drop the
|
|
|
|
|
|
ctf_file_close_thunk.
|
|
|
|
|
|
(ctf_link_in_member_cb_arg_t) <file_name> Rename to...
|
|
|
|
|
|
<in_file_name>: ... this.
|
|
|
|
|
|
<arcname>: Drop.
|
|
|
|
|
|
<share_mode>: Likewise (migrated to ctf_link_flags).
|
|
|
|
|
|
<done_main_member>: Rename to...
|
|
|
|
|
|
<done_parent>: ... this.
|
|
|
|
|
|
<main_input_fp>: Rename to...
|
|
|
|
|
|
<in_fp_parent>: ... this.
|
|
|
|
|
|
<cu_mapped>: New.
|
|
|
|
|
|
(ctf_link_one_type): Adjuwt accordingly. Transition to
|
|
|
|
|
|
ctf_err_warn, removing a TODO.
|
|
|
|
|
|
(ctf_link_one_variable): Note a case too common to warn about.
|
|
|
|
|
|
Report in the debug stream if a cu-mapped link prevents addition
|
|
|
|
|
|
of a conflicting variable.
|
|
|
|
|
|
(ctf_link_one_input_archive_member): Adjust.
|
|
|
|
|
|
(ctf_link_lazy_open): New, open a CTF archive for linking when
|
|
|
|
|
|
needed.
|
|
|
|
|
|
(ctf_link_close_one_input_archive): New, close it again.
|
|
|
|
|
|
(ctf_link_one_input_archive): Adjust for lazy opening, member
|
|
|
|
|
|
renames, and ctf_err_warn transition. Move the
|
|
|
|
|
|
empty_link_type_mapping call to...
|
|
|
|
|
|
(ctf_link): ... here. Adjut for renamings and thunk removal.
|
|
|
|
|
|
Don't spuriously fail if some input contains no CTF data.
|
|
|
|
|
|
(ctf_link_write): ctf_err_warn transition.
|
|
|
|
|
|
* libctf.ver: Remove not-yet-stable comment.
|
|
|
|
|
|
|
2020-06-05 01:07:38 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_strerror): Delete.
|
|
|
|
|
|
* ctf-subr.c (ctf_strerror): Likewise.
|
|
|
|
|
|
* ctf-error.c (ctf_errmsg): Stop using ctf_strerror: just use
|
|
|
|
|
|
strerror directly.
|
|
|
|
|
|
|
libctf: sort out potential refcount loops
When you link TUs that contain conflicting types together, the resulting
CTF section is an archive containing many CTF dicts. These dicts appear
in ctf_link_outputs of the shared dict, with each ctf_import'ing that
shared dict. ctf_importing a dict bumps its refcount to stop it going
away while it's in use -- but if the shared dict (whose refcount is
bumped) has the child dict (doing the bumping) in its ctf_link_outputs,
we have a refcount loop, since the child dict only un-ctf_imports and
drops the parent's refcount when it is freed, but the child is only
freed when the parent's refcount falls to zero.
(In the future, this will be able to go wrong on the inputs too, when an
ld -r'ed deduplicated output with conflicts is relinked. Right now this
cannot happen because we don't ctf_import such dicts at all. This will
be fixed in a later commit in this series.)
Fix this by introducing an internal-use-only ctf_import_unref function
that imports a parent dict *witthout* bumping the parent's refcount, and
using it when we create per-CU outputs. This function is only safe to
use if you know the parent cannot go away while the child exists: but if
the parent *owns* the child, as here, this is necessarily true.
Record in the ctf_file_t whether a parent was imported via ctf_import or
ctf_import_unref, so that if you do another ctf_import later on (or a
ctf_import_unref) it can decide whether to drop the refcount of the
existing parent being replaced depending on which function you used to
import that one. Adjust ctf_serialize so that rather than doing a
ctf_import (which is wrong if the original import was
ctf_import_unref'fed), we just copy the parent field and refcount over
and forcibly flip the unref flag on on the old copy we are going to
discard.
ctf_file_close also needs a bit of tweaking to only close the parent if
it was not imported with ctf_import_unref: while we're at it, guard
against repeated closes with a refcount of zero and stop them causing
double-frees, even if destruction of things freed *inside*
ctf_file_close cause such recursion.
Verified no leaks or accesses to freed memory after all of this with
valgrind. (It was leak-happy before.)
libctf/
* ctf-impl.c (ctf_file_t) <ctf_parent_unreffed>: New.
(ctf_import_unref): New.
* ctf-open.c (ctf_file_close) Drop the refcount all the way to
zero. Don't recurse back in if the refcount is already zero.
(ctf_import): Check ctf_parent_unreffed before deciding whether
to close a pre-existing parent. Set it to zero.
(ctf_import_unreffed): New, as above, setting
ctf_parent_unreffed to 1.
* ctf-create.c (ctf_serialize): Do not ctf_import into the new
child: use direct assignment, and set unreffed on the new and
old children.
* ctf-link.c (ctf_create_per_cu): Import the parent using
ctf_import_unreffed.
2020-06-05 00:30:01 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.c (ctf_file_t) <ctf_parent_unreffed>: New.
|
|
|
|
|
|
(ctf_import_unref): New.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close) Drop the refcount all the way to
|
|
|
|
|
|
zero. Don't recurse back in if the refcount is already zero.
|
|
|
|
|
|
(ctf_import): Check ctf_parent_unreffed before deciding whether
|
|
|
|
|
|
to close a pre-existing parent. Set it to zero.
|
|
|
|
|
|
(ctf_import_unreffed): New, as above, setting
|
|
|
|
|
|
ctf_parent_unreffed to 1.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Do not ctf_import into the new
|
|
|
|
|
|
child: use direct assignment, and set unreffed on the new and
|
|
|
|
|
|
old children.
|
|
|
|
|
|
* ctf-link.c (ctf_create_per_cu): Import the parent using
|
|
|
|
|
|
ctf_import_unreffed.
|
|
|
|
|
|
|
2020-06-05 00:21:10 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_link_type_mapping_key): Rename to...
|
|
|
|
|
|
(ctf_link_type_key): ... this, adjusting member prefixes to
|
|
|
|
|
|
match.
|
|
|
|
|
|
(ctf_hash_type_mapping_key): Rename to...
|
|
|
|
|
|
(ctf_hash_type_key): ... this.
|
|
|
|
|
|
(ctf_hash_eq_type_mapping_key): Rename to...
|
|
|
|
|
|
(ctf_hash_eq_type_key): ... this.
|
|
|
|
|
|
* ctf-hash.c (ctf_hash_type_mapping_key): Rename to...
|
|
|
|
|
|
(ctf_hash_type_key): ... this, and adjust for member name
|
|
|
|
|
|
changes.
|
|
|
|
|
|
(ctf_hash_eq_type_mapping_key): Rename to...
|
|
|
|
|
|
(ctf_hash_eq_type_key): ... this, and adjust for member name
|
|
|
|
|
|
changes.
|
|
|
|
|
|
* ctf-link.c (ctf_add_type_mapping): Adjust. Note the lack of
|
|
|
|
|
|
need for out-of-memory checking in this code.
|
|
|
|
|
|
(ctf_type_mapping): Adjust.
|
|
|
|
|
|
|
2020-06-05 00:16:09 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
configure.ac: Check for vasprintf.
|
|
|
|
|
|
configure: Regenerated.
|
|
|
|
|
|
config.h.in: Likewise.
|
|
|
|
|
|
|
2020-06-09 18:18:25 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_bufopen): Fix message.
|
|
|
|
|
|
|
libctf, open: fix opening CTF in binaries with no symtab
This is a perfectly possible case, and half of ctf_bfdopen_ctfsect
handled it fine. The other half hit a divide by zero or two before we
got that far, and had no code path to load the strtab from anywhere
in the absence of a symtab to point at it in any case.
So, as a fallback, if there is no symtab, try loading ".strtab"
explicitly by name, like we used to before we started looking for the
strtab the symtab used.
Of course, such a strtab is not kept hold of by BFD, so this means we
have to bring back the code to possibly explicitly free the strtab that
we read in.
libctf/
* ctf-impl.h (struct ctf_archive_internal) <ctfi_free_strsect>
New.
* ctf-open-bfd.c (ctf_bfdopen_ctfsect): Explicitly open a strtab
if the input has no symtab, rather than dividing by
zero. Arrange to free it later via ctfi_free_ctfsect.
* ctf-archive.c (ctf_new_archive_internal): Do not
ctfi_free_strsect by default.
(ctf_arc_close): Possibly free it here.
2020-06-09 17:27:57 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (struct ctf_archive_internal) <ctfi_free_strsect>
|
|
|
|
|
|
New.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_bfdopen_ctfsect): Explicitly open a strtab
|
|
|
|
|
|
if the input has no symtab, rather than dividing by
|
|
|
|
|
|
zero. Arrange to free it later via ctfi_free_ctfsect.
|
|
|
|
|
|
* ctf-archive.c (ctf_new_archive_internal): Do not
|
|
|
|
|
|
ctfi_free_strsect by default.
|
|
|
|
|
|
(ctf_arc_close): Possibly free it here.
|
|
|
|
|
|
|
libctf, dump: fix slice dumping
Now that we can have slices of anything terminating in an int, we must
dump things accordingly, or slices of typedefs appear as
c5b: __u8 -> 16c: __u8 -> 78: short unsigned int (size 0x2)
which is unhelpful. If things *are* printed as slices, the name is
missing:
a15: [slice 0x8:0x4]-> 16c: __u8 -> 78: short unsigned int (size 0x2)
And struct members give no clue they're a slice at all, which is a shame
since bitfields are the major use of this type kind:
[0x8] (ID 0xa15) (kind 10) __u8 dst_reg
Fix things so that everything slicelike or integral gets its encoding
printed, and everything with a name gets the name printed:
a15: __u8 [slice 0x8:0x4] (size 0x1) -> 1ff: __u8 (size 0x1) -> 37: unsigned char [0x0:0x8] (size 0x1)
[0x0] (ID 0xa15) (kind 10) __u8:4 (aligned at 0x1, format 0x2, offset:bits 0x8:0x4)
Bitfield struct members get a technically redundant but much
easier-to-understand dumping now:
[0x0] (ID 0x80000005) (kind 6) struct bpf_insn (aligned at 0x1)
[0x0] (ID 0x222) (kind 10) __u8 code (aligned at 0x1)
[0x8] (ID 0x1e9e) (kind 10) __u8 dst_reg:4 (aligned at 0x1, format 0x2, offset:bits 0x8:0x4)
[0xc] (ID 0x1e46) (kind 10) __u8 src_reg:4 (aligned at 0x1, format 0x2, offset:bits 0xc:0x4)
[0x10] (ID 0xf35) (kind 10) __s16 off (aligned at 0x2)
[0x20] (ID 0x1718) (kind 10) __s32 imm (aligned at 0x4)
This also fixes one place where a failure to format a type would be
erroneously considered an out-of-memory condition.
libctf/
* ctf-dump.c (ctf_is_slice): Delete, unnecessary.
(ctf_dump_format_type): improve slice formatting. Always print
the type size, even of slices.
(ctf_dump_member): Print slices (-> bitfields) differently from
non-slices. Failure to format a type is not an OOM.
2020-05-12 01:18:50 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_is_slice): Delete, unnecessary.
|
|
|
|
|
|
(ctf_dump_format_type): improve slice formatting. Always print
|
|
|
|
|
|
the type size, even of slices.
|
|
|
|
|
|
(ctf_dump_member): Print slices (-> bitfields) differently from
|
|
|
|
|
|
non-slices. Failure to format a type is not an OOM.
|
|
|
|
|
|
|
2020-06-04 22:38:26 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_format_type): Emit a warning.
|
|
|
|
|
|
(ctf_dump_label): Swallow errors from ctf_dump_format_type.
|
|
|
|
|
|
(ctf_dump_objts): Likewise.
|
|
|
|
|
|
(ctf_dump_var): Likewise.
|
|
|
|
|
|
(ctf_dump_type): Do not emit a duplicate message. Move to
|
|
|
|
|
|
ctf_err_warning, and swallow all errors.
|
|
|
|
|
|
|
2020-06-09 17:45:07 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-decl.c (ctf_decl_fini): Free the cd_buf.
|
|
|
|
|
|
(ctf_decl_buf): Once it escapes, don't try to free it later.
|
|
|
|
|
|
|
2020-06-04 22:25:32 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_aname): Print arg types here...
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_funcs): ... not here: but do substitute
|
|
|
|
|
|
in the type name here.
|
|
|
|
|
|
|
libctf, ld, binutils: add textual error/warning reporting for libctf
This commit adds a long-missing piece of infrastructure to libctf: the
ability to report errors and warnings using all the power of printf,
rather than being restricted to one errno value. Internally, libctf
calls ctf_err_warn() to add errors and warnings to a list: a new
iterator ctf_errwarning_next() then consumes this list one by one and
hands it to the caller, which can free it. New errors and warnings are
added until the list is consumed by the caller or the ctf_file_t is
closed, so you can dump them at intervals. The caller can of course
choose to print only those warnings it wants. (I am not sure whether we
want objdump, readelf or ld to print warnings or not: right now I'm
printing them, but maybe we only want to print errors? This entirely
depends on whether warnings are voluminous things describing e.g. the
inability to emit single types because of name clashes or something.
There are no users of this infrastructure yet, so it's hard to say.)
There is no internationalization here yet, but this at least adds a
place where internationalization can be added, to one of
ctf_errwarning_next or ctf_err_warn.
We also provide a new ctf_assert() function which uses this
infrastructure to provide non-fatal assertion failures while emitting an
assert-like string to the caller: to save space and avoid needlessly
duplicating unchanging strings, the assertion test is inlined but the
print-things-out failure case is not. All assertions in libctf will be
converted to use this machinery in future commits and propagate
assertion-failure errors up, so that the linker in particular cannot be
killed by libctf assertion failures when it could perfectly well just
print warnings and drop the CTF section.
include/
* ctf-api.h (ECTF_INTERNAL): Adjust error text.
(ctf_errwarning_next): New.
libctf/
* ctf-impl.h (ctf_assert): New.
(ctf_err_warning_t): Likewise.
(ctf_file_t) <ctf_errs_warnings>: Likewise.
(ctf_err_warn): New prototype.
(ctf_assert_fail_internal): Likewise.
* ctf-inlines.h (ctf_assert_internal): Likewise.
* ctf-open.c (ctf_file_close): Free ctf_errs_warnings.
* ctf-create.c (ctf_serialize): Copy it on serialization.
* ctf-subr.c (ctf_err_warn): New, add an error/warning.
(ctf_errwarning_next): New iterator, free and pass back
errors/warnings in succession.
* libctf.ver (ctf_errwarning_next): Add.
ld/
* ldlang.c (lang_ctf_errs_warnings): New, print CTF errors
and warnings. Assert when libctf asserts.
(lang_merge_ctf): Call it.
(land_write_ctf): Likewise.
binutils/
* objdump.c (ctf_archive_member): Print CTF errors and warnings.
* readelf.c (dump_ctf_archive_member): Likewise.
2020-06-04 22:07:54 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_assert): New.
|
|
|
|
|
|
(ctf_err_warning_t): Likewise.
|
|
|
|
|
|
(ctf_file_t) <ctf_errs_warnings>: Likewise.
|
|
|
|
|
|
(ctf_err_warn): New prototype.
|
|
|
|
|
|
(ctf_assert_fail_internal): Likewise.
|
|
|
|
|
|
* ctf-inlines.h (ctf_assert_internal): Likewise.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Free ctf_errs_warnings.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Copy it on serialization.
|
|
|
|
|
|
* ctf-subr.c (ctf_err_warn): New, add an error/warning.
|
|
|
|
|
|
(ctf_errwarning_next): New iterator, free and pass back
|
|
|
|
|
|
errors/warnings in succession.
|
|
|
|
|
|
* libctf.ver (ctf_errwarning_next): Add.
|
|
|
|
|
|
|
2020-06-04 00:36:51 +08:00
|
|
|
|
2020-07-22 Egeyar Bagcioglu <egeyar.bagcioglu@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_variable_iter): Fix error return.
|
|
|
|
|
|
|
2020-06-04 00:31:44 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_bufopen_internal): Diagnose invalid flags.
|
|
|
|
|
|
|
2020-07-01 01:02:28 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
ctf-decls.h (ctf_qsort_compar_thunk): Fix arg passing.
|
|
|
|
|
|
|
2020-06-03 23:36:18 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_next_hkv_t): New, kv-pairs passed to
|
|
|
|
|
|
sorting functions.
|
|
|
|
|
|
(ctf_next_t) <u.ctn_sorted_hkv>: New, sorted kv-pairs for
|
|
|
|
|
|
ctf_dynhash_next_sorted.
|
|
|
|
|
|
<cu.ctn_h>: New, pointer to the dynhash under iteration.
|
|
|
|
|
|
<cu.ctn_s>: New, pointer to the dynset under iteration.
|
|
|
|
|
|
(ctf_hash_sort_f): Sorting function passed to...
|
|
|
|
|
|
(ctf_dynhash_next_sorted): ... this new function.
|
|
|
|
|
|
(ctf_dynhash_next): New.
|
|
|
|
|
|
(ctf_dynset_next): New.
|
|
|
|
|
|
* ctf-inlines.h (ctf_dynhash_cnext_sorted): New.
|
|
|
|
|
|
(ctf_dynhash_cnext): New.
|
|
|
|
|
|
(ctf_dynset_cnext): New.
|
|
|
|
|
|
* ctf-hash.c (ctf_dynhash_next_sorted): New.
|
|
|
|
|
|
(ctf_dynhash_next): New.
|
|
|
|
|
|
(ctf_dynset_next): New.
|
|
|
|
|
|
* ctf-util.c (ctf_next_destroy): Free the u.ctn_sorted_hkv if
|
|
|
|
|
|
needed.
|
|
|
|
|
|
(ctf_next_copy): Alloc-and-copy the u.ctn_sorted_hkv if needed.
|
|
|
|
|
|
|
libctf, next: introduce new class of easier-to-use iterators
The libctf machinery currently only provides one way to iterate over its
data structures: ctf_*_iter functions that take a callback and an arg
and repeatedly call it.
This *works*, but if you are doing a lot of iteration it is really quite
inconvenient: you have to package up your local variables into
structures over and over again and spawn lots of little functions even
if it would be clearer in a single run of code. Look at ctf-string.c
for an extreme example of how unreadable this can get, with
three-line-long functions proliferating wildly.
The deduplicator takes this to the Nth level. It iterates over a whole
bunch of things: if we'd had to use _iter-class iterators for all of
them there would be twenty additional functions in the deduplicator
alone, for no other reason than that the iterator API requires it.
Let's do something better. strtok_r gives us half the design: generators
in a number of other languages give us the other half.
The *_next API allows you to iterate over CTF-like entities in a single
function using a normal while loop. e.g. here we are iterating over all
the types in a dict:
ctf_next_t *i = NULL;
int *hidden;
ctf_id_t id;
while ((id = ctf_type_next (fp, &i, &hidden, 1)) != CTF_ERR)
{
/* do something with 'hidden' and 'id' */
}
if (ctf_errno (fp) != ECTF_NEXT_END)
/* iteration error */
Here we are walking through the members of a struct with CTF ID
'struct_type':
ctf_next_t *i = NULL;
ssize_t offset;
const char *name;
ctf_id_t membtype;
while ((offset = ctf_member_next (fp, struct_type, &i, &name,
&membtype)) >= 0
{
/* do something with offset, name, and membtype */
}
if (ctf_errno (fp) != ECTF_NEXT_END)
/* iteration error */
Like every other while loop, this means you have access to all the local
variables outside the loop while inside it, with no need to tiresomely
package things up in structures, move the body of the loop into a
separate function, etc, as you would with an iterator taking a callback.
ctf_*_next allocates 'i' for you on first entry (when it must be NULL),
and frees and NULLs it and returns a _next-dependent flag value when the
iteration is over: the fp errno is set to ECTF_NEXT_END when the
iteartion ends normally. If you want to exit early, call
ctf_next_destroy on the iterator. You can copy iterators using
ctf_next_copy, which copies their current iteration position so you can
remember loop positions and go back to them later (or ctf_next_destroy
them if you don't need them after all).
Each _next function returns an always-likely-to-be-useful property of
the thing being iterated over, and takes pointers to parameters for the
others: with very few exceptions all those parameters can be NULLs if
you're not interested in them, so e.g. you can iterate over only the
offsets of members of a structure this way:
while ((offset = ctf_member_next (fp, struct_id, &i, NULL, NULL)) >= 0)
If you pass an iterator in use by one iteration function to another one,
you get the new error ECTF_NEXT_WRONGFUN back; if you try to change
ctf_file_t in mid-iteration, you get ECTF_NEXT_WRONGFP back.
Internally the ctf_next_t remembers the iteration function in use,
various sizes and increments useful for almost all iterations, then
uses unions to overlap the actual entities being iterated over to keep
ctf_next_t size down.
Iterators available in the public API so far (all tested in actual use
in the deduplicator):
/* Iterate over the members of a STRUCT or UNION, returning each member's
offset and optionally name and member type in turn. On end-of-iteration,
returns -1. */
ssize_t
ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
const char **name, ctf_id_t *membtype);
/* Iterate over the members of an enum TYPE, returning each enumerand's
NAME or NULL at end of iteration or error, and optionally passing
back the enumerand's integer VALue. */
const char *
ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
int *val);
/* Iterate over every type in the given CTF container (not including
parents), optionally including non-user-visible types, returning
each type ID and optionally the hidden flag in turn. Returns CTF_ERR
on end of iteration or error. */
ctf_id_t
ctf_type_next (ctf_file_t *fp, ctf_next_t **it, int *flag,
int want_hidden);
/* Iterate over every variable in the given CTF container, in arbitrary
order, returning the name and type of each variable in turn. The
NAME argument is not optional. Returns CTF_ERR on end of iteration
or error. */
ctf_id_t
ctf_variable_next (ctf_file_t *fp, ctf_next_t **it, const char **name);
/* Iterate over all CTF files in an archive, returning each dict in turn as a
ctf_file_t, and NULL on error or end of iteration. It is the caller's
responsibility to close it. Parent dicts may be skipped. Regardless of
whether they are skipped or not, the caller must ctf_import the parent if
need be. */
ctf_file_t *
ctf_archive_next (const ctf_archive_t *wrapper, ctf_next_t **it,
const char **name, int skip_parent, int *errp);
ctf_label_next is prototyped but not implemented yet.
include/
* ctf-api.h (ECTF_NEXT_END): New error.
(ECTF_NEXT_WRONGFUN): Likewise.
(ECTF_NEXT_WRONGFP): Likewise.
(ECTF_NERR): Adjust.
(ctf_next_t): New.
(ctf_next_create): New prototype.
(ctf_next_destroy): Likewise.
(ctf_next_copy): Likewise.
(ctf_member_next): Likewise.
(ctf_enum_next): Likewise.
(ctf_type_next): Likewise.
(ctf_label_next): Likewise.
(ctf_variable_next): Likewise.
libctf/
* ctf-impl.h (ctf_next): New.
(ctf_get_dict): New prototype.
* ctf-lookup.c (ctf_get_dict): New, split out of...
(ctf_lookup_by_id): ... here.
* ctf-util.c (ctf_next_create): New.
(ctf_next_destroy): New.
(ctf_next_copy): New.
* ctf-types.c (includes): Add <assert.h>.
(ctf_member_next): New.
(ctf_enum_next): New.
(ctf_type_iter): Document the lack of iteration over parent
types.
(ctf_type_next): New.
(ctf_variable_next): New.
* ctf-archive.c (ctf_archive_next): New.
* libctf.ver: Add new public functions.
2020-06-03 22:13:24 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_next): New.
|
|
|
|
|
|
(ctf_get_dict): New prototype.
|
|
|
|
|
|
* ctf-lookup.c (ctf_get_dict): New, split out of...
|
|
|
|
|
|
(ctf_lookup_by_id): ... here.
|
|
|
|
|
|
* ctf-util.c (ctf_next_create): New.
|
|
|
|
|
|
(ctf_next_destroy): New.
|
|
|
|
|
|
(ctf_next_copy): New.
|
|
|
|
|
|
* ctf-types.c (includes): Add <assert.h>.
|
|
|
|
|
|
(ctf_member_next): New.
|
|
|
|
|
|
(ctf_enum_next): New.
|
|
|
|
|
|
(ctf_type_iter): Document the lack of iteration over parent
|
|
|
|
|
|
types.
|
|
|
|
|
|
(ctf_type_next): New.
|
|
|
|
|
|
(ctf_variable_next): New.
|
|
|
|
|
|
* ctf-archive.c (ctf_archive_next): New.
|
|
|
|
|
|
* libctf.ver: Add new public functions.
|
|
|
|
|
|
|
2020-06-08 16:24:01 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* libctf.ver (ctf_ref): New.
|
|
|
|
|
|
* ctf-open.c (ctf_ref): Implement it.
|
|
|
|
|
|
|
2020-06-03 20:23:42 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-inlines.h (ctf_forwardable_kind): New.
|
|
|
|
|
|
* ctf-create.c (ctf_add_forward): Use it.
|
|
|
|
|
|
|
2020-06-03 20:21:56 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_get_ctt_size): Move definition from here...
|
|
|
|
|
|
* ctf-inlines.h (ctf_get_ctt_size): ... to here.
|
|
|
|
|
|
|
libctf, hash: introduce the ctf_dynset
There are many places in the deduplicator which use hashtables as tiny
sets: keys with no value (and usually, but not always, no freeing
function) often with only one or a few members. For each of these, even
after the last change to not store the freeing functions, we are storing
a little malloced block for each item just to track the key/value pair,
and a little malloced block for the hash table itself just to track the
freeing function because we can't use libiberty hashtab's freeing
function because we are using that to free the little malloced per-item
block.
If we only have a key, we don't need any of that: we can ditch the
per-malloced block because we don't have a value, and we can ditch the
per-hashtab structure because we don't need to independently track the
freeing functions since libiberty hashtab is doing it for us. That
means we don't need an owner field in the (now nonexistent) item block
either.
Roughly speaking, this datatype saves about 25% in time and 20% in peak
memory usage for normal links, even fairly big ones. So this might seem
redundant, but it's really worth it.
Instead of a _lookup function, a dynset has two distinct functions:
ctf_dynset_exists, which returns true or false and an optional pointer
to the set member, and ctf_dynhash_lookup_any, which is used if all
members of the set are expected to be equivalent and we just want *any*
member and we don't care which one.
There is no iterator in this set of functions, not because we don't
iterate over dynset members -- we do, a lot -- but because the iterator
here is a member of an entirely new family of much more convenient
iteration functions, introduced in the next commit.
libctf/
* ctf-hash.c (ctf_dynset_eq_string): New.
(ctf_dynset_create): New.
(DYNSET_EMPTY_ENTRY_REPLACEMENT): New.
(DYNSET_DELETED_ENTRY_REPLACEMENT): New.
(key_to_internal): New.
(internal_to_key): New.
(ctf_dynset_insert): New.
(ctf_dynset_remove): New.
(ctf_dynset_destroy): New.
(ctf_dynset_lookup): New.
(ctf_dynset_exists): New.
(ctf_dynset_lookup_any): New.
(ctf_hash_insert_type): Coding style.
(ctf_hash_define_type): Likewise.
* ctf-impl.h (ctf_dynset_t): New.
(ctf_dynset_eq_string): New.
(ctf_dynset_create): New.
(ctf_dynset_insert): New.
(ctf_dynset_remove): New.
(ctf_dynset_destroy): New.
(ctf_dynset_lookup): New.
(ctf_dynset_exists): New.
(ctf_dynset_lookup_any): New.
* ctf-inlines.h (ctf_dynset_cinsert): New.
2020-06-03 05:26:38 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c (ctf_dynset_eq_string): New.
|
|
|
|
|
|
(ctf_dynset_create): New.
|
|
|
|
|
|
(DYNSET_EMPTY_ENTRY_REPLACEMENT): New.
|
|
|
|
|
|
(DYNSET_DELETED_ENTRY_REPLACEMENT): New.
|
|
|
|
|
|
(key_to_internal): New.
|
|
|
|
|
|
(internal_to_key): New.
|
|
|
|
|
|
(ctf_dynset_insert): New.
|
|
|
|
|
|
(ctf_dynset_remove): New.
|
|
|
|
|
|
(ctf_dynset_destroy): New.
|
|
|
|
|
|
(ctf_dynset_lookup): New.
|
|
|
|
|
|
(ctf_dynset_exists): New.
|
|
|
|
|
|
(ctf_dynset_lookup_any): New.
|
|
|
|
|
|
(ctf_hash_insert_type): Coding style.
|
|
|
|
|
|
(ctf_hash_define_type): Likewise.
|
|
|
|
|
|
* ctf-impl.h (ctf_dynset_t): New.
|
|
|
|
|
|
(ctf_dynset_eq_string): New.
|
|
|
|
|
|
(ctf_dynset_create): New.
|
|
|
|
|
|
(ctf_dynset_insert): New.
|
|
|
|
|
|
(ctf_dynset_remove): New.
|
|
|
|
|
|
(ctf_dynset_destroy): New.
|
|
|
|
|
|
(ctf_dynset_lookup): New.
|
|
|
|
|
|
(ctf_dynset_exists): New.
|
|
|
|
|
|
(ctf_dynset_lookup_any): New.
|
|
|
|
|
|
* ctf-inlines.h (ctf_dynset_cinsert): New.
|
|
|
|
|
|
|
2020-06-03 05:00:14 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c (ctf_helem_t) <key_free>: Remove.
|
|
|
|
|
|
<value_free>: Likewise.
|
|
|
|
|
|
<owner>: New.
|
|
|
|
|
|
(ctf_dynhash_item_free): Indirect through the owner.
|
|
|
|
|
|
(ctf_dynhash_create): Only pass in ctf_dynhash_item_free and
|
|
|
|
|
|
allocate space for the key_free and value_free fields fields
|
|
|
|
|
|
if necessary.
|
|
|
|
|
|
(ctf_hashtab_insert): Likewise. Fix OOM errno value.
|
|
|
|
|
|
(ctf_dynhash_insert): Only access ctf_hashtab's key_free and
|
|
|
|
|
|
value_free if they will exist. Set the slot's owner, but only
|
|
|
|
|
|
if it exists.
|
|
|
|
|
|
(ctf_dynhash_remove): Adjust.
|
|
|
|
|
|
|
2020-06-03 04:48:12 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c (ctf_hashtab_insert): Free the key passed in if
|
|
|
|
|
|
there is a key-freeing function and the key already exists.
|
|
|
|
|
|
|
2020-06-03 04:31:45 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-inlines.h: New file.
|
|
|
|
|
|
* ctf-impl.h: Include it.
|
|
|
|
|
|
(ctf_hash_iter_find_f): New typedef.
|
|
|
|
|
|
(ctf_dynhash_elements): New.
|
|
|
|
|
|
(ctf_dynhash_lookup_kv): New.
|
|
|
|
|
|
(ctf_dynhash_iter_find): New.
|
|
|
|
|
|
* ctf-hash.c (ctf_dynhash_lookup_kv): New.
|
|
|
|
|
|
(ctf_traverse_find_cb_arg_t): New.
|
|
|
|
|
|
(ctf_hashtab_traverse_find): New.
|
|
|
|
|
|
(ctf_dynhash_iter_find): New.
|
|
|
|
|
|
(ctf_dynhash_elements): New.
|
|
|
|
|
|
|
2020-06-03 04:16:15 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h [!__GNUC__] (__extension__): Define to nothing.
|
|
|
|
|
|
|
2020-06-03 04:14:22 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_archive_count): New.
|
|
|
|
|
|
* libctf.ver: New public function.
|
|
|
|
|
|
|
2020-06-03 04:11:25 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_member_count): New.
|
|
|
|
|
|
* libctf.ver: New public function.
|
|
|
|
|
|
|
2020-06-03 04:09:49 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_kind_forwarded): New.
|
|
|
|
|
|
|
2020-06-03 04:06:18 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_name_raw): New.
|
|
|
|
|
|
(ctf_type_aname_raw): Reimplement accordingly.
|
|
|
|
|
|
|
2020-06-03 04:00:35 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-subr.c (ctf_dprintf): _libctf_debug is unlikely to be set.
|
|
|
|
|
|
|
2020-06-03 03:55:05 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (struct ctf_archive_internal)
|
|
|
|
|
|
<ctfi_unmap_on_close>: New.
|
|
|
|
|
|
(ctf_new_archive_internal): Adjust.
|
|
|
|
|
|
* ctf-archive.c (ctf_new_archive_internal): Likewise.
|
|
|
|
|
|
Initialize ctfi_unmap_on_close. Adjust error path.
|
|
|
|
|
|
(ctf_arc_bufopen): Adjust ctf_new_archive_internal call
|
|
|
|
|
|
(unmap_on_close is 0).
|
|
|
|
|
|
(ctf_arc_close): Only unmap if ctfi_unmap_on_close.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_fdopen): Adjust.
|
|
|
|
|
|
|
2020-06-03 03:49:14 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_aname): Return ECTF_CORRUPT if
|
|
|
|
|
|
ints, floats or typedefs have no name. Fix comment typo.
|
|
|
|
|
|
|
2020-06-03 03:43:03 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_slice): Support slices of any kind that
|
|
|
|
|
|
resolves to an integral type.
|
|
|
|
|
|
* ctf-types.c (ctf_type_encoding): Resolve the type before
|
|
|
|
|
|
fishing its encoding out.
|
|
|
|
|
|
|
2020-06-03 03:39:15 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_create): Mark dirty.
|
|
|
|
|
|
|
2020-06-03 03:38:17 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (membcmp) Skip nameless members.
|
|
|
|
|
|
|
2020-06-03 03:28:16 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_member_offset): Support names of ""
|
|
|
|
|
|
as if they were the null pointer.
|
|
|
|
|
|
|
2020-06-03 03:26:29 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (init_types): Remove typeless CTF_K_FORWARD
|
|
|
|
|
|
special-casing.
|
|
|
|
|
|
|
2020-06-03 03:25:02 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_reference): Add support for dynamic slices.
|
|
|
|
|
|
|
2020-06-03 03:23:07 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Add cast.
|
|
|
|
|
|
(ctf_add_slice): Likewise.
|
|
|
|
|
|
|
libctf, create: do not corrupt function types' arglists at insertion time
ctf_add_function assumes that function types' arglists are of type
ctf_id_t. Since they are CTF IDs, they are 32 bits wide, a uint32_t:
unfortunately ctf_id_t is a forward-compatible user-facing 64 bits wide,
and should never ever reach the CTF storage level.
All the CTF code other than ctf_add_function correctly assumes that
function arglists outside dynamic containers are 32 bits wide, so the
serialization machinery ends up cutting off half the arglist, corrupting
all args but the first (a good sign is a bunch of args of ID 0, the
unimplemented type, popping up).
Fix this by copying the arglist into place item by item, casting it
properly, at the same time as we validate the arg types. Fix the type
of the dtu_argv in the dynamic container and drop the now-unnecessary
cast in the serializer.
libctf/
* ctf-impl.h (ctf_dtdef_t) <dtu_argv>: Fix type.
* ctf-create.c (ctf_add_function): Check for unimplemented type
and populate at the same time. Populate one-by-one, not via
memcpy.
(ctf_serialize): Remove unnecessary cast.
* ctf-types.c (ctf_func_type_info): Likewise.
(ctf_func_type_args): Likewise. Fix comment typo.
2020-06-03 03:17:51 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_dtdef_t) <dtu_argv>: Fix type.
|
|
|
|
|
|
* ctf-create.c (ctf_add_function): Check for unimplemented type
|
|
|
|
|
|
and populate at the same time. Populate one-by-one, not via
|
|
|
|
|
|
memcpy.
|
|
|
|
|
|
(ctf_serialize): Remove unnecessary cast.
|
|
|
|
|
|
* ctf-types.c (ctf_func_type_info): Likewise.
|
|
|
|
|
|
(ctf_func_type_args): Likewise. Fix comment typo.
|
|
|
|
|
|
|
2020-06-03 03:04:24 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_reftype): Support refs to type zero.
|
|
|
|
|
|
(ctf_add_array): Support array contents of type zero.
|
|
|
|
|
|
(ctf_add_function): Support arguments and return types of
|
|
|
|
|
|
type zero.
|
|
|
|
|
|
(ctf_add_typedef): Support typedefs to type zero.
|
|
|
|
|
|
(ctf_add_member_offset): Support members of type zero,
|
|
|
|
|
|
unless added at unspecified (naturally-aligned) offset.
|
|
|
|
|
|
|
libctf: restructure error handling to reduce relocations
Jose Marchesi noted that the traditional-Unix error array in ctf-error.c
introduces one reloc per error to initialize the array: 58 so far. We
can reduce this to zero using an array of carefully-sized individual
members which is used to construct a string table, that is then
referenced by the lookup functions: but doing this automatically is a
pain.
Bruno Haible wrote suitable code years ago: I got permission to reuse it
(Bruno says "... which I hereby put in the public domain"); I modified
it a tiny bit (similarly to what Ulrich Drepper did in the dsohowto
text, but I redid it from scratch), commented it up a bit, and shifted
the error table into that form, migrating it into the new file
ctf-error.h.
This has the advantage that it spotted both typos in the text of the
errors in the comments in ctf-api.h and typos in the error defines in
the comments in ctf-error.c, and places where the two were simply not
in sync. All are now fixed.
One new constant exists in ctf-api.h: CTF_NERR, since the old method of
working out the number of errors in ctf-error.c was no longer usable,
and it seems that the number of CTF errors is something users might
reasonably want as well. It should be pretty easy to keep up to date as
new errors are introduced.
include/
* ctf-api.h (ECTF_*): Improve comments.
(ECTF_NERR): New.
libctf/
* ctf-error.c: Include <stddef.h>, for offsetof.
(_ctf_errlist): Migrate to...
(_ctf_errlist_t): ... this.
(_ctf_erridx): New, indexes into _ctf_errlist_t.
(_ctf_nerr): Remove.
(ctf_errmsg): Adjust accordingly.
* Makefile.am (BUILT_SOURCES): Note...
(ctf-error.h): ... this new rule.
* Makefile.in: Regenerate.
* mkerrors.sed: New, process ctf-api.h to generate ctf-error.h.
* .gitignore: New, ignore ctf-error.h.
2020-06-03 02:07:08 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-error.c: Include <stddef.h>, for offsetof.
|
|
|
|
|
|
(_ctf_errlist): Migrate to...
|
|
|
|
|
|
(_ctf_errlist_t): ... this.
|
|
|
|
|
|
(_ctf_erridx): New, indexes into _ctf_errlist_t.
|
|
|
|
|
|
(_ctf_nerr): Remove.
|
|
|
|
|
|
(ctf_errmsg): Adjust accordingly.
|
|
|
|
|
|
* Makefile.am (BUILT_SOURCES): Note...
|
|
|
|
|
|
(ctf-error.h): ... this new rule.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
* mkerrors.sed: New, process ctf-api.h to generate ctf-error.h.
|
|
|
|
|
|
* .gitignore: New, ignore ctf-error.h.
|
|
|
|
|
|
|
2020-06-03 01:56:06 +08:00
|
|
|
|
2020-07-22 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h: Fix typos in comments.
|
|
|
|
|
|
|
2020-07-22 23:07:48 +08:00
|
|
|
|
2020-07-22 Nick Clifton <nickc@redhat.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_write): Avoid calling close twice on the
|
|
|
|
|
|
same file descriptor.
|
|
|
|
|
|
|
2020-07-04 17:16:22 +08:00
|
|
|
|
2020-07-04 Nick Clifton <nickc@redhat.com>
|
|
|
|
|
|
|
|
|
|
|
|
Binutils 2.35 branch created.
|
|
|
|
|
|
|
2019-12-16 22:17:26 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* aclocal.m4: Add config/gettext-sister.m4: Shuffle into
|
|
|
|
|
|
alphabetical order.
|
|
|
|
|
|
* configure.ac: Add ZW_GNU_GETTEXT_SISTER_DIR.
|
|
|
|
|
|
* config.h.in: Regenerated.
|
|
|
|
|
|
* Makefile.in: Likewise.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
2019-12-16 19:38:57 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c: Include <unistd.h>.
|
|
|
|
|
|
* ctf-open-bfd.c: Likewise.
|
|
|
|
|
|
|
libctf, elfcpp, gold: do not assume that <byteswap.h> contains bswap_*
At least one C library (uclibc-ng) defines some of these only when
the compiler is GCC. We might as well test for all three cases and
handle any of them being missing.
Very similar code exists in libctf and split between elfcpp and gold:
fix both.
(Also sync up elfcpp with a change made to libctf swap.h a few months
ago: since there is no out-of-line definition of the bswap replacements,
they should be declared static inline, not just inline, to prevent the
linker generating out-of-line references to them.)
PR libctf/25120
libctf/
* configure.ac: Check for bswap_16, bswap_32, and bswap_64 decls.
* swap.h (bswap_16): Do not assume that presence of <byteswap.h>
means this is declared.
(bswap_32): Likewise.
(bswap_64): Likewise.
(bswap_identity_64): Remove, unused.
* configure: Regenerated.
* config.h.in: Likewise.
gold/
* configure.ac: Check for bswap_16, bswap_32, and bswap_64 decls.
* configure: Regenerated.
* config.h.in: Likewise.
elfcpp/
* elfcpp_swap.h (bswap_16): Do not assume that presence of
<byteswap.h> means this is declared. Make static inline, matching
recent change to libctf, since there is no non-inline definition
of these functions.
(bswap_32): Likewise.
(bswap_64): Likewise.
2019-12-13 23:19:17 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
PR libctf/25120
|
|
|
|
|
|
* configure.ac: Check for bswap_16, bswap_32, and bswap_64 decls.
|
|
|
|
|
|
* swap.h (bswap_16): Do not assume that presence of <byteswap.h>
|
|
|
|
|
|
means this is declared.
|
|
|
|
|
|
(bswap_32): Likewise.
|
|
|
|
|
|
(bswap_64): Likewise.
|
|
|
|
|
|
(bswap_identity_64): Remove, unused.
|
|
|
|
|
|
* configure: Regenerated.
|
|
|
|
|
|
* config.h.in: Likewise.
|
|
|
|
|
|
|
2019-12-13 22:54:09 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
PR libctf/25120
|
|
|
|
|
|
* ctf-impl.h (_libctf_printflike_): Add non-GNU-C fallback.
|
|
|
|
|
|
(_libctf_unlikely_): Likewise.
|
|
|
|
|
|
(_libctf_unused): Likewise.
|
|
|
|
|
|
(_libctf_malloc_): Likewise.
|
|
|
|
|
|
|
2019-12-13 22:48:07 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
PR libctf/25120
|
|
|
|
|
|
* ctf-archive.c (search_nametbl): No longer global: declare...
|
|
|
|
|
|
(ctf_arc_open_by_name_internal): ... here. Use bsearch_r.
|
|
|
|
|
|
(search_modent_by_name): Take and use ARG for the nametbl.
|
|
|
|
|
|
|
libctf, binutils: support CTF archives like objdump
objdump and readelf have one major CTF-related behavioural difference:
objdump can read .ctf sections that contain CTF archives and extract and
dump their members, while readelf cannot. Since the linker often emits
CTF archives, this means that readelf intermittently and (from the
user's perspective) randomly fails to read CTF in files that ld emits,
with a confusing error message wrongly claiming that the CTF content is
corrupt. This is purely because the archive-opening code in libctf was
needlessly tangled up with the BFD code, so readelf couldn't use it.
Here, we disentangle it, moving ctf_new_archive_internal from
ctf-open-bfd.c into ctf-archive.c and merging it with the helper
function in ctf-archive.c it was already using. We add a new public API
function ctf_arc_bufopen, that looks very like ctf_bufopen but returns
an archive given suitable section data rather than a ctf_file_t: the
archive is a ctf_archive_t, so it can be called on raw CTF dictionaries
(with no archive present) and will return a single-member synthetic
"archive".
There is a tiny lifetime tweak here: before now, the archive code could
assume that the symbol section in the ctf_archive_internal wrapper
structure was always owned by BFD if it was present and should always be
freed: now, the caller can pass one in via ctf_arc_bufopen, wihch has
the usual lifetime rules for such sections (caller frees): so we add an
extra field to track whether this is an internal call from ctf-open-bfd,
in which case we still free the symbol section.
include/
* ctf-api.h (ctf_arc_bufopen): New.
libctf/
* ctf-impl.h (ctf_new_archive_internal): Declare.
(ctf_arc_bufopen): Remove.
(ctf_archive_internal) <ctfi_free_symsect>: New.
* ctf-archive.c (ctf_arc_close): Use it.
(ctf_arc_bufopen): Fuse into...
(ctf_new_archive_internal): ... this, moved across from...
* ctf-open-bfd.c: ... here.
(ctf_bfdopen_ctfsect): Use ctf_arc_bufopen.
* libctf.ver: Add it.
binutils/
* readelf.c (dump_section_as_ctf): Support .ctf archives using
ctf_arc_bufopen. Automatically load the .ctf member of such
archives as the parent of all other members, unless specifically
overridden via --ctf-parent. Split out dumping code into...
(dump_ctf_archive_member): ... here, as in objdump, and call
it once per archive member.
(dump_ctf_indent_lines): Code style fix.
2019-12-13 20:01:12 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_new_archive_internal): Declare.
|
|
|
|
|
|
(ctf_arc_bufopen): Remove.
|
|
|
|
|
|
(ctf_archive_internal) <ctfi_free_symsect>: New.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_close): Use it.
|
|
|
|
|
|
(ctf_arc_bufopen): Fuse into...
|
|
|
|
|
|
(ctf_new_archive_internal): ... this, moved across from...
|
|
|
|
|
|
* ctf-open-bfd.c: ... here.
|
|
|
|
|
|
(ctf_bfdopen_ctfsect): Use ctf_arc_bufopen.
|
|
|
|
|
|
* libctf.ver: Add it.
|
|
|
|
|
|
|
libctf: create: forwards are always in the namespace of their referent
The C namespace a forward is located in is always the same as the
namespace of the corresponding complete type: 'struct foo' is in the
struct namespace and does not collide with, say, 'union foo'.
libctf allowed for this in many places, but inconsistently: in
particular, forward *addition* never allowed for this, and was interning
forwards in the default namespace, which is always wrong, since you can
only forward structs, unions and enums, all of which are in their own
namespaces in C.
Forward removal needs corresponding adjustment to remove the names form
the right namespace, as does ctf_rollback.
libctf/
* ctf-create.c (ctf_add_forward): Intern in the right namespace.
(ctf_dtd_delete): Remove correspondingly.
(ctf_rollback): Likewise.
2019-11-06 01:57:55 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_forward): Intern in the right namespace.
|
|
|
|
|
|
(ctf_dtd_delete): Remove correspondingly.
|
|
|
|
|
|
(ctf_rollback): Likewise.
|
|
|
|
|
|
|
2019-11-05 21:09:57 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_type_internal): Hand back existing types
|
|
|
|
|
|
unchanged.
|
|
|
|
|
|
|
2019-10-21 18:33:19 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_forward): Don't add forwards to
|
|
|
|
|
|
types that already exist.
|
|
|
|
|
|
|
2019-10-21 18:27:43 +08:00
|
|
|
|
2020-06-26 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (init_types): Only intern root-visible types.
|
|
|
|
|
|
* ctf-create.c (ctf_dtd_insert): Likewise.
|
|
|
|
|
|
(ctf_dtd_delete): Only remove root-visible types.
|
|
|
|
|
|
(ctf_rollback): Likewise.
|
|
|
|
|
|
(ctf_add_generic): Adjust.
|
|
|
|
|
|
(ctf_add_struct_sized): Adjust comment.
|
|
|
|
|
|
(ctf_add_union_sized): Likewise.
|
|
|
|
|
|
(ctf_add_enum): Likewise.
|
|
|
|
|
|
* ctf-impl.h (ctf_dtd_insert): Adjust prototype.
|
|
|
|
|
|
|
2020-03-06 06:27:08 +08:00
|
|
|
|
2020-03-11 John Baldwin <jhb@FreeBSD.org>
|
|
|
|
|
|
|
|
|
|
|
|
* swap.h (bswap_identity_64): Make static.
|
|
|
|
|
|
|
2020-01-18 21:50:25 +08:00
|
|
|
|
2020-01-18 Nick Clifton <nickc@redhat.com>
|
|
|
|
|
|
|
|
|
|
|
|
Binutils 2.34 branch created.
|
|
|
|
|
|
|
2020-01-05 13:53:14 +08:00
|
|
|
|
2020-01-05 Joel Brobecker <brobecker@adacore.com>
|
2020-01-05 13:50:27 +08:00
|
|
|
|
|
|
|
|
|
|
PR binutils/25155:
|
|
|
|
|
|
* configure.ac: Add AC_CHECK_DECLS([asprintf]).
|
|
|
|
|
|
* configure, config.h.in: Regenerate.
|
|
|
|
|
|
|
2020-01-01 16:22:19 +08:00
|
|
|
|
2020-01-01 Alan Modra <amodra@gmail.com>
|
|
|
|
|
|
|
|
|
|
|
|
Update year range in copyright notice of all files.
|
|
|
|
|
|
|
libctf: mark swap.h inline functions as static
When building binutils with mingw-w64, I get the following errors:
make[4]: Entering directory '/home/simark/build/binutils-gdb-mingw/binutils'
/bin/sh ./libtool --tag=CC --mode=link ccache x86_64-w64-mingw32-gcc -W -Wall -Wstrict-prototypes -Wmissing-prototypes -Wshadow -Wstack-usage=262144 -Wno-format -Werror -I/home/simark/src/binutils-gdb/binutils/../zlib -g3 -O0 -D__USE_MINGW_ACCESS -Wl,--stack,12582912 -o objdump.exe objdump.o dwarf.o prdbg.o rddbg.o debug.o stabs.o rdcoff.o bucomm.o version.o filemode.o elfcomm.o ../opcodes/libopcodes.la ../libctf/libctf.la ../bfd/libbfd.la ../libiberty/libiberty.a -lintl
libtool: link: ccache x86_64-w64-mingw32-gcc -W -Wall -Wstrict-prototypes -Wmissing-prototypes -Wshadow -Wstack-usage=262144 -Wno-format -Werror -I/home/simark/src/binutils-gdb/binutils/../zlib -g3 -O0 -D__USE_MINGW_ACCESS -Wl,--stack -Wl,12582912 -o .libs/objdump.exe objdump.o dwarf.o prdbg.o rddbg.o debug.o stabs.o rdcoff.o bucomm.o version.o filemode.o elfcomm.o ../opcodes/.libs/libopcodes.a ../libctf/.libs/libctf.a -L/home/simark/build/binutils-gdb-mingw/zlib ../bfd/.libs/libbfd.a -lz ../libiberty/libiberty.a -lintl
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open.o): in function `flip_header':
/home/simark/src/binutils-gdb/libctf/ctf-open.c:964: undefined reference to `bswap_16'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:967: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:968: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:969: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:970: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:971: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open.o):/home/simark/src/binutils-gdb/libctf/ctf-open.c:972: more undefined references to `bswap_32' follow
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open.o): in function `flip_types':
/home/simark/src/binutils-gdb/libctf/ctf-open.c:1112: undefined reference to `bswap_16'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1113: undefined reference to `bswap_16'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1132: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1133: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1134: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1135: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: /home/simark/src/binutils-gdb/libctf/ctf-open.c:1144: undefined reference to `bswap_32'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open.o):/home/simark/src/binutils-gdb/libctf/ctf-open.c:1145: more undefined references to `bswap_32' follow
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open.o): in function `ctf_bufopen_internal':
/home/simark/src/binutils-gdb/libctf/ctf-open.c:1342: undefined reference to `bswap_16'
/usr/lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/bin/ld: ../libctf/.libs/libctf.a(ctf-open-bfd.o): in function `ctf_fdopen':
/home/simark/src/binutils-gdb/libctf/ctf-open-bfd.c:268: undefined reference to `bswap_16'
Apparently [1], if we have a function with `inline` but not `static`,
there should be a compilation unit defining the symbol too.
Alternatively, making those functions `static` fixes that.
[1] https://stackoverflow.com/questions/16245521/c99-inline-function-in-c-file/16254679#16254679
libctf/ChangeLog:
* swap.h (bswap_16, bswap_32, bswap_64): Make static.
Change-Id: I8fd12aedf6c90f9b7418af948e5e0bae0c32eead
2019-10-16 23:11:28 +08:00
|
|
|
|
2019-10-16 Simon Marchi <simon.marchi@polymtl.ca>
|
|
|
|
|
|
|
|
|
|
|
|
* swap.h (bswap_16, bswap_32, bswap_64): Make static.
|
|
|
|
|
|
|
2019-09-26 22:26:48 +08:00
|
|
|
|
2019-09-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_bufopen_internal): Fix tabdamage.
|
|
|
|
|
|
* ctf-types.c (ctf_type_lname): Likewise.
|
|
|
|
|
|
|
2019-09-17 13:59:31 +08:00
|
|
|
|
2019-09-23 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_import): Do not leak a ctf_file_t ref on every
|
|
|
|
|
|
ctf_import after the first for a given file.
|
|
|
|
|
|
|
2019-09-17 13:57:00 +08:00
|
|
|
|
2019-09-23 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_str_append_noerr): Declare.
|
|
|
|
|
|
* ctf-util.c (ctf_str_append_noerr): Define in terms of
|
|
|
|
|
|
ctf_str_append.
|
|
|
|
|
|
* ctf-dump.c (str_append): New, call it.
|
|
|
|
|
|
(ctf_dump_format_type): Use str_append, not ctf_str_append.
|
|
|
|
|
|
(ctf_dump_label): Likewise.
|
|
|
|
|
|
(ctf_dump_objts): Likewise.
|
|
|
|
|
|
(ctf_dump_funcs): Likewise.
|
|
|
|
|
|
(ctf_dump_var): Likewise.
|
|
|
|
|
|
(ctf_dump_member): Likewise.
|
|
|
|
|
|
(ctf_dump_type): Likewise.
|
|
|
|
|
|
(ctf_dump): Likewise.
|
|
|
|
|
|
|
libctf: remove ctf_malloc, ctf_free and ctf_strdup
These just get in the way of auditing for erroneous usage of strdup and
add a huge irregular surface of "ctf_malloc or malloc? ctf_free or free?
ctf_strdup or strdup?"
ctf_malloc and ctf_free usage has not reliably matched up for many
years, if ever, making the whole game pointless.
Go back to malloc, free, and strdup like everyone else: while we're at
it, fix a bunch of places where we weren't properly checking for OOM.
This changes the interface of ctf_cuname_set and ctf_parent_name_set,
which could strdup but could not return errors (like ENOMEM).
New in v4.
include/
* ctf-api.h (ctf_cuname_set): Can now fail, returning int.
(ctf_parent_name_set): Likewise.
libctf/
* ctf-impl.h (ctf_alloc): Remove.
(ctf_free): Likewise.
(ctf_strdup): Likewise.
* ctf-subr.c (ctf_alloc): Remove.
(ctf_free): Likewise.
* ctf-util.c (ctf_strdup): Remove.
* ctf-create.c (ctf_serialize): Use malloc, not ctf_alloc; free, not
ctf_free; strdup, not ctf_strdup.
(ctf_dtd_delete): Likewise.
(ctf_dvd_delete): Likewise.
(ctf_add_generic): Likewise.
(ctf_add_function): Likewise.
(ctf_add_enumerator): Likewise.
(ctf_add_member_offset): Likewise.
(ctf_add_variable): Likewise.
(membadd): Likewise.
(ctf_compress_write): Likewise.
(ctf_write_mem): Likewise.
* ctf-decl.c (ctf_decl_push): Likewise.
(ctf_decl_fini): Likewise.
(ctf_decl_sprintf): Likewise. Check for OOM.
* ctf-dump.c (ctf_dump_append): Use malloc, not ctf_alloc; free, not
ctf_free; strdup, not ctf_strdup.
(ctf_dump_free): Likewise.
(ctf_dump): Likewise.
* ctf-open.c (upgrade_types_v1): Likewise.
(init_types): Likewise.
(ctf_file_close): Likewise.
(ctf_bufopen_internal): Likewise. Check for OOM.
(ctf_parent_name_set): Likewise: report the OOM to the caller.
(ctf_cuname_set): Likewise.
(ctf_import): Likewise.
* ctf-string.c (ctf_str_purge_atom_refs): Use malloc, not ctf_alloc;
free, not ctf_free; strdup, not ctf_strdup.
(ctf_str_free_atom): Likewise.
(ctf_str_create_atoms): Likewise.
(ctf_str_add_ref_internal): Likewise.
(ctf_str_remove_ref): Likewise.
(ctf_str_write_strtab): Likewise.
2019-09-17 13:54:23 +08:00
|
|
|
|
2019-09-23 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_alloc): Remove.
|
|
|
|
|
|
(ctf_free): Likewise.
|
|
|
|
|
|
(ctf_strdup): Likewise.
|
|
|
|
|
|
* ctf-subr.c (ctf_alloc): Remove.
|
|
|
|
|
|
(ctf_free): Likewise.
|
|
|
|
|
|
* ctf-util.c (ctf_strdup): Remove.
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Use malloc, not ctf_alloc; free, not
|
|
|
|
|
|
ctf_free; strdup, not ctf_strdup.
|
|
|
|
|
|
(ctf_dtd_delete): Likewise.
|
|
|
|
|
|
(ctf_dvd_delete): Likewise.
|
|
|
|
|
|
(ctf_add_generic): Likewise.
|
|
|
|
|
|
(ctf_add_function): Likewise.
|
|
|
|
|
|
(ctf_add_enumerator): Likewise.
|
|
|
|
|
|
(ctf_add_member_offset): Likewise.
|
|
|
|
|
|
(ctf_add_variable): Likewise.
|
|
|
|
|
|
(membadd): Likewise.
|
|
|
|
|
|
(ctf_compress_write): Likewise.
|
|
|
|
|
|
(ctf_write_mem): Likewise.
|
|
|
|
|
|
* ctf-decl.c (ctf_decl_push): Likewise.
|
|
|
|
|
|
(ctf_decl_fini): Likewise.
|
|
|
|
|
|
(ctf_decl_sprintf): Likewise. Check for OOM.
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_append): Use malloc, not ctf_alloc; free, not
|
|
|
|
|
|
ctf_free; strdup, not ctf_strdup.
|
|
|
|
|
|
(ctf_dump_free): Likewise.
|
|
|
|
|
|
(ctf_dump): Likewise.
|
|
|
|
|
|
* ctf-open.c (upgrade_types_v1): Likewise.
|
|
|
|
|
|
(init_types): Likewise.
|
|
|
|
|
|
(ctf_file_close): Likewise.
|
|
|
|
|
|
(ctf_bufopen_internal): Likewise. Check for OOM.
|
|
|
|
|
|
(ctf_parent_name_set): Likewise: report the OOM to the caller.
|
|
|
|
|
|
(ctf_cuname_set): Likewise.
|
|
|
|
|
|
(ctf_import): Likewise.
|
|
|
|
|
|
* ctf-string.c (ctf_str_purge_atom_refs): Use malloc, not ctf_alloc;
|
|
|
|
|
|
free, not ctf_free; strdup, not ctf_strdup.
|
|
|
|
|
|
(ctf_str_free_atom): Likewise.
|
|
|
|
|
|
(ctf_str_create_atoms): Likewise.
|
|
|
|
|
|
(ctf_str_add_ref_internal): Likewise.
|
|
|
|
|
|
(ctf_str_remove_ref): Likewise.
|
|
|
|
|
|
(ctf_str_write_strtab): Likewise.
|
|
|
|
|
|
|
2019-08-10 05:53:50 +08:00
|
|
|
|
2019-08-09 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_encoding): Fix the dynamic case to
|
|
|
|
|
|
work right for non-int/fps.
|
|
|
|
|
|
|
2019-08-08 23:53:48 +08:00
|
|
|
|
2019-08-08 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_name): Don't strlen a potentially-
|
|
|
|
|
|
null pointer.
|
|
|
|
|
|
|
libctf: properly handle ctf_add_type of forwards and self-reffing structs
The code to handle structures (and unions) that refer to themselves in
ctf_add_type is extremely dodgy. It works by looking through the list
of not-yet-committed types for a structure with the same name as the
structure in question and assuming, if it finds it, that this must be a
reference to the same type. This is a linear search that gets ever
slower as the dictionary grows, requiring you to call ctf_update at
intervals to keep performance tolerable: but if you do that, you run
into the problem that if a forward declared before the ctf_update is
changed to a structure afterwards, ctf_update explodes.
The last commit fixed most of this: this commit can use it, adding a new
ctf_add_processing hash that tracks source type IDs that are currently
being processed and uses it to avoid infinite recursion rather than the
dynamic type list: we split ctf_add_type into a ctf_add_type_internal,
so that ctf_add_type itself can become a wrapper that empties out this
being-processed hash once the entire recursive type addition is over.
Structure additions themselves avoid adding their dependent types
quite so much by checking the type mapping and avoiding re-adding types
we already know we have added.
We also add support for adding forwards to dictionaries that already
contain the thing they are a forward to: we just silently return the
original type.
v4: return existing struct/union/enum types properly, rather than using
an uninitialized variable: shrinks sizes of CTF sections back down
to roughly where they were in v1/v2 of this patch series.
v5: fix tabdamage.
libctf/
* ctf-impl.h (ctf_file_t) <ctf_add_processing>: New.
* ctf-open.c (ctf_file_close): Free it.
* ctf-create.c (ctf_serialize): Adjust.
(membcmp): When reporting a conflict due to an error, report the
error.
(ctf_add_type): Turn into a ctf_add_processing wrapper. Rename to...
(ctf_add_type_internal): ... this. Hand back types we are already
in the middle of adding immediately. Hand back structs/unions with
the same number of members immediately. Do not walk the dynamic
list. Call ctf_add_type_internal, not ctf_add_type. Handle
forwards promoted to other types and the inverse case identically.
Add structs to the mapping as soon as we intern them, before they
gain any members.
2019-08-08 01:01:08 +08:00
|
|
|
|
2019-08-07 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t) <ctf_add_processing>: New.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Free it.
|
|
|
|
|
|
* ctf-create.c (ctf_serialize): Adjust.
|
|
|
|
|
|
(membcmp): When reporting a conflict due to an error, report the
|
|
|
|
|
|
error.
|
|
|
|
|
|
(ctf_add_type): Turn into a ctf_add_processing wrapper. Rename to...
|
|
|
|
|
|
(ctf_add_type_internal): ... this. Hand back types we are already
|
|
|
|
|
|
in the middle of adding immediately. Hand back structs/unions with
|
|
|
|
|
|
the same number of members immediately. Do not walk the dynamic
|
|
|
|
|
|
list. Call ctf_add_type_internal, not ctf_add_type. Handle
|
|
|
|
|
|
forwards promoted to other types and the inverse case identically.
|
|
|
|
|
|
Add structs to the mapping as soon as we intern them, before they
|
|
|
|
|
|
gain any members.
|
|
|
|
|
|
|
libctf: avoid the need to ever use ctf_update
The method of operation of libctf when the dictionary is writable has
before now been that types that are added land in the dynamic type
section, which is a linked list and hash of IDs -> dynamic type
definitions (and, recently a hash of names): the DTDs are a bit of CTF
representing the ctf_type_t and ad hoc C structures representing the
vlen. Historically, libctf was unable to do anything with these types,
not even look them up by ID, let alone by name: if you wanted to do that
say if you were adding a type that depended on one you just added) you
called ctf_update, which serializes all the DTDs into a CTF file and
reopens it, copying its guts over the fp it's called with. The
ctf_updated types are then frozen in amber and unchangeable: all lookups
will return the types in the static portion in preference to the dynamic
portion, and we will refuse to re-add things that already exist in the
static portion (and, of late, in the dynamic portion too). The libctf
machinery remembers the boundary between static and dynamic types and
looks in the right portion for each type. Lots of things still don't
quite work with dynamic types (e.g. getting their size), but enough
works to do a bunch of additions and then a ctf_update, most of the
time.
Except it doesn't, because ctf_add_type finds it necessary to walk the
full dynamic type definition list looking for types with matching names,
so it gets slower and slower with every type you add: fixing this
requires calling ctf_update periodically for no other reason than to
avoid massively slowing things down.
This is all clunky and very slow but kind of works, until you consider
that it is in fact possible and indeed necessary to modify one sort of
type after it has been added: forwards. These are necessarily promoted
to structs, unions or enums, and when they do so *their type ID does not
change*. So all of a sudden we are changing types that already exist in
the static portion. ctf_update gets massively confused by this and
allocates space enough for the forward (with no members), but then emits
the new dynamic type (with all the members) into it. You get an
assertion failure after that, if you're lucky, or a coredump.
So this commit rejigs things a bit and arranges to exclusively use the
dynamic type definitions in writable dictionaries, and the static type
definitions in readable dictionaries: we don't at any time have a mixture
of static and dynamic types, and you don't need to call ctf_update to
make things "appear". The ctf_dtbyname hash I introduced a few months
ago, which maps things like "struct foo" to DTDs, is removed, replaced
instead by a change of type of the four dictionaries which track names.
Rather than just being (unresizable) ctf_hash_t's populated only at
ctf_bufopen time, they are now a ctf_names_t structure, which is a pair
of ctf_hash_t and ctf_dynhash_t, with the ctf_hash_t portion being used
in readonly dictionaries, and the ctf_dynhash_t being used in writable
ones. The decision as to which to use is centralized in the new
functions ctf_lookup_by_rawname (which takes a type kind) and
ctf_lookup_by_rawhash, which it calls (which takes a ctf_names_t *.)
This change lets us switch from using static to dynamic name hashes on
the fly across the entirety of libctf without complexifying anything: in
fact, because we now centralize the knowledge about how to map from type
kind to name hash, it actually simplifies things and lets us throw out
quite a lot of now-unnecessary complexity, from ctf_dtnyname (replaced
by the dynamic half of the name tables), through to ctf_dtnextid (now
that a dictionary's static portion is never referenced if the dictionary
is writable, we can just use ctf_typemax to indicate the maximum type:
dynamic or non-dynamic does not matter, and we no longer need to track
the boundary between the types). You can now ctf_rollback() as far as
you like, even past a ctf_update or for that matter a full writeout; all
the iteration functions work just as well on writable as on read-only
dictionaries; ctf_add_type no longer needs expensive duplicated code to
run over the dynamic types hunting for ones it might be interested in;
and the linker no longer needs a hack to call ctf_update so that calling
ctf_add_type is not impossibly expensive.
There is still a bit more complexity: some new code paths in ctf-types.c
need to know how to extract information from dynamic types. This
complexity will go away again in a few months when libctf acquires a
proper intermediate representation.
You can still call ctf_update if you like (it's public API, after all),
but its only effect now is to set the point to which ctf_discard rolls
back.
Obviously *something* still needs to serialize the CTF file before
writeout, and this job is done by ctf_serialize, which does everything
ctf_update used to except set the counter used by ctf_discard. It is
automatically called by the various functions that do CTF writeout:
nobody else ever needs to call it.
With this in place, forwards that are promoted to non-forwards no longer
crash the link, even if it happens tens of thousands of types later.
v5: fix tabdamage.
libctf/
* ctf-impl.h (ctf_names_t): New.
(ctf_lookup_t) <ctf_hash>: Now a ctf_names_t, not a ctf_hash_t.
(ctf_file_t) <ctf_structs>: Likewise.
<ctf_unions>: Likewise.
<ctf_enums>: Likewise.
<ctf_names>: Likewise.
<ctf_lookups>: Improve comment.
<ctf_ptrtab_len>: New.
<ctf_prov_strtab>: New.
<ctf_str_prov_offset>: New.
<ctf_dtbyname>: Remove, redundant to the names hashes.
<ctf_dtnextid>: Remove, redundant to ctf_typemax.
(ctf_dtdef_t) <dtd_name>: Remove.
<dtd_data>: Note that the ctt_name is now populated.
(ctf_str_atom_t) <csa_offset>: This is now the strtab
offset for internal strings too.
<csa_external_offset>: New, the external strtab offset.
(CTF_INDEX_TO_TYPEPTR): Handle the LCTF_RDWR case.
(ctf_name_table): New declaration.
(ctf_lookup_by_rawname): Likewise.
(ctf_lookup_by_rawhash): Likewise.
(ctf_set_ctl_hashes): Likewise.
(ctf_serialize): Likewise.
(ctf_dtd_insert): Adjust.
(ctf_simple_open_internal): Likewise.
(ctf_bufopen_internal): Likewise.
(ctf_list_empty_p): Likewise.
(ctf_str_remove_ref): Likewise.
(ctf_str_add): Returns uint32_t now.
(ctf_str_add_ref): Likewise.
(ctf_str_add_external): Now returns a boolean (int).
* ctf-string.c (ctf_strraw_explicit): Check the ctf_prov_strtab
for strings in the appropriate range.
(ctf_str_create_atoms): Create the ctf_prov_strtab. Detect OOM
when adding the null string to the new strtab.
(ctf_str_free_atoms): Destroy the ctf_prov_strtab.
(ctf_str_add_ref_internal): Add make_provisional argument. If
make_provisional, populate the offset and fill in the
ctf_prov_strtab accordingly.
(ctf_str_add): Return the offset, not the string.
(ctf_str_add_ref): Likewise.
(ctf_str_add_external): Return a success integer.
(ctf_str_remove_ref): New, remove a single ref.
(ctf_str_count_strtab): Do not count the initial null string's
length or the existence or length of any unreferenced internal
atoms.
(ctf_str_populate_sorttab): Skip atoms with no refs.
(ctf_str_write_strtab): Populate the nullstr earlier. Add one
to the cts_len for the null string, since it is no longer done
in ctf_str_count_strtab. Adjust for csa_external_offset rename.
Populate the csa_offset for both internal and external cases.
Flush the ctf_prov_strtab afterwards, and reset the
ctf_str_prov_offset.
* ctf-create.c (ctf_grow_ptrtab): New.
(ctf_create): Call it. Initialize new fields rather than old
ones. Tell ctf_bufopen_internal that this is a writable dictionary.
Set the ctl hashes and data model.
(ctf_update): Rename to...
(ctf_serialize): ... this. Leave a compatibility function behind.
Tell ctf_simple_open_internal that this is a writable dictionary.
Pass the new fields along from the old dictionary. Drop
ctf_dtnextid and ctf_dtbyname. Use ctf_strraw, not dtd_name.
Do not zero out the DTD's ctt_name.
(ctf_prefixed_name): Rename to...
(ctf_name_table): ... this. No longer return a prefixed name: return
the applicable name table instead.
(ctf_dtd_insert): Use it, and use the right name table. Pass in the
kind we're adding. Migrate away from dtd_name.
(ctf_dtd_delete): Adjust similarly. Remove the ref to the
deleted ctt_name.
(ctf_dtd_lookup_type_by_name): Remove.
(ctf_dynamic_type): Always return NULL on read-only dictionaries.
No longer check ctf_dtnextid: check ctf_typemax instead.
(ctf_snapshot): No longer use ctf_dtnextid: use ctf_typemax instead.
(ctf_rollback): Likewise. No longer fail with ECTF_OVERROLLBACK. Use
ctf_name_table and the right name table, and migrate away from
dtd_name as in ctf_dtd_delete.
(ctf_add_generic): Pass in the kind explicitly and pass it to
ctf_dtd_insert. Use ctf_typemax, not ctf_dtnextid. Migrate away
from dtd_name to using ctf_str_add_ref to populate the ctt_name.
Grow the ptrtab if needed.
(ctf_add_encoded): Pass in the kind.
(ctf_add_slice): Likewise.
(ctf_add_array): Likewise.
(ctf_add_function): Likewise.
(ctf_add_typedef): Likewise.
(ctf_add_reftype): Likewise. Initialize the ctf_ptrtab, checking
ctt_name rather than dtd_name.
(ctf_add_struct_sized): Pass in the kind. Use
ctf_lookup_by_rawname, not ctf_hash_lookup_type /
ctf_dtd_lookup_type_by_name.
(ctf_add_union_sized): Likewise.
(ctf_add_enum): Likewise.
(ctf_add_enum_encoded): Likewise.
(ctf_add_forward): Likewise.
(ctf_add_type): Likewise.
(ctf_compress_write): Call ctf_serialize: adjust for ctf_size not
being initialized until after the call.
(ctf_write_mem): Likewise.
(ctf_write): Likewise.
* ctf-archive.c (arc_write_one_ctf): Likewise.
* ctf-lookup.c (ctf_lookup_by_name): Use ctf_lookuup_by_rawhash, not
ctf_hash_lookup_type.
(ctf_lookup_by_id): No longer check the readonly types if the
dictionary is writable.
* ctf-open.c (init_types): Assert that this dictionary is not
writable. Adjust to use the new name hashes, ctf_name_table,
and ctf_ptrtab_len. GNU style fix for the final ptrtab scan.
(ctf_bufopen_internal): New 'writable' parameter. Flip on LCTF_RDWR
if set. Drop out early when dictionary is writable. Split the
ctf_lookups initialization into...
(ctf_set_cth_hashes): ... this new function.
(ctf_simple_open_internal): Adjust. New 'writable' parameter.
(ctf_simple_open): Adjust accordingly.
(ctf_bufopen): Likewise.
(ctf_file_close): Destroy the appropriate name hashes. No longer
destroy ctf_dtbyname, which is gone.
(ctf_getdatasect): Remove spurious "extern".
* ctf-types.c (ctf_lookup_by_rawname): New, look up types in the
specified name table, given a kind.
(ctf_lookup_by_rawhash): Likewise, given a ctf_names_t *.
(ctf_member_iter): Add support for iterating over the
dynamic type list.
(ctf_enum_iter): Likewise.
(ctf_variable_iter): Likewise.
(ctf_type_rvisit): Likewise.
(ctf_member_info): Add support for types in the dynamic type list.
(ctf_enum_name): Likewise.
(ctf_enum_value): Likewise.
(ctf_func_type_info): Likewise.
(ctf_func_type_args): Likewise.
* ctf-link.c (ctf_accumulate_archive_names): No longer call
ctf_update.
(ctf_link_write): Likewise.
(ctf_link_intern_extern_string): Adjust for new
ctf_str_add_external return value.
(ctf_link_add_strtab): Likewise.
* ctf-util.c (ctf_list_empty_p): New.
2019-08-08 00:55:09 +08:00
|
|
|
|
2019-08-09 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_names_t): New.
|
|
|
|
|
|
(ctf_lookup_t) <ctf_hash>: Now a ctf_names_t, not a ctf_hash_t.
|
|
|
|
|
|
(ctf_file_t) <ctf_structs>: Likewise.
|
|
|
|
|
|
<ctf_unions>: Likewise.
|
|
|
|
|
|
<ctf_enums>: Likewise.
|
|
|
|
|
|
<ctf_names>: Likewise.
|
|
|
|
|
|
<ctf_lookups>: Improve comment.
|
|
|
|
|
|
<ctf_ptrtab_len>: New.
|
|
|
|
|
|
<ctf_prov_strtab>: New.
|
|
|
|
|
|
<ctf_str_prov_offset>: New.
|
|
|
|
|
|
<ctf_dtbyname>: Remove, redundant to the names hashes.
|
|
|
|
|
|
<ctf_dtnextid>: Remove, redundant to ctf_typemax.
|
|
|
|
|
|
(ctf_dtdef_t) <dtd_name>: Remove.
|
|
|
|
|
|
<dtd_data>: Note that the ctt_name is now populated.
|
|
|
|
|
|
(ctf_str_atom_t) <csa_offset>: This is now the strtab
|
|
|
|
|
|
offset for internal strings too.
|
|
|
|
|
|
<csa_external_offset>: New, the external strtab offset.
|
|
|
|
|
|
(CTF_INDEX_TO_TYPEPTR): Handle the LCTF_RDWR case.
|
|
|
|
|
|
(ctf_name_table): New declaration.
|
|
|
|
|
|
(ctf_lookup_by_rawname): Likewise.
|
|
|
|
|
|
(ctf_lookup_by_rawhash): Likewise.
|
|
|
|
|
|
(ctf_set_ctl_hashes): Likewise.
|
|
|
|
|
|
(ctf_serialize): Likewise.
|
|
|
|
|
|
(ctf_dtd_insert): Adjust.
|
|
|
|
|
|
(ctf_simple_open_internal): Likewise.
|
|
|
|
|
|
(ctf_bufopen_internal): Likewise.
|
|
|
|
|
|
(ctf_list_empty_p): Likewise.
|
|
|
|
|
|
(ctf_str_remove_ref): Likewise.
|
|
|
|
|
|
(ctf_str_add): Returns uint32_t now.
|
|
|
|
|
|
(ctf_str_add_ref): Likewise.
|
|
|
|
|
|
(ctf_str_add_external): Now returns a boolean (int).
|
|
|
|
|
|
* ctf-string.c (ctf_strraw_explicit): Check the ctf_prov_strtab
|
|
|
|
|
|
for strings in the appropriate range.
|
|
|
|
|
|
(ctf_str_create_atoms): Create the ctf_prov_strtab. Detect OOM
|
|
|
|
|
|
when adding the null string to the new strtab.
|
|
|
|
|
|
(ctf_str_free_atoms): Destroy the ctf_prov_strtab.
|
|
|
|
|
|
(ctf_str_add_ref_internal): Add make_provisional argument. If
|
|
|
|
|
|
make_provisional, populate the offset and fill in the
|
|
|
|
|
|
ctf_prov_strtab accordingly.
|
|
|
|
|
|
(ctf_str_add): Return the offset, not the string.
|
|
|
|
|
|
(ctf_str_add_ref): Likewise.
|
|
|
|
|
|
(ctf_str_add_external): Return a success integer.
|
|
|
|
|
|
(ctf_str_remove_ref): New, remove a single ref.
|
|
|
|
|
|
(ctf_str_count_strtab): Do not count the initial null string's
|
|
|
|
|
|
length or the existence or length of any unreferenced internal
|
|
|
|
|
|
atoms.
|
|
|
|
|
|
(ctf_str_populate_sorttab): Skip atoms with no refs.
|
|
|
|
|
|
(ctf_str_write_strtab): Populate the nullstr earlier. Add one
|
|
|
|
|
|
to the cts_len for the null string, since it is no longer done
|
|
|
|
|
|
in ctf_str_count_strtab. Adjust for csa_external_offset rename.
|
|
|
|
|
|
Populate the csa_offset for both internal and external cases.
|
|
|
|
|
|
Flush the ctf_prov_strtab afterwards, and reset the
|
|
|
|
|
|
ctf_str_prov_offset.
|
|
|
|
|
|
* ctf-create.c (ctf_grow_ptrtab): New.
|
|
|
|
|
|
(ctf_create): Call it. Initialize new fields rather than old
|
|
|
|
|
|
ones. Tell ctf_bufopen_internal that this is a writable dictionary.
|
|
|
|
|
|
Set the ctl hashes and data model.
|
|
|
|
|
|
(ctf_update): Rename to...
|
|
|
|
|
|
(ctf_serialize): ... this. Leave a compatibility function behind.
|
|
|
|
|
|
Tell ctf_simple_open_internal that this is a writable dictionary.
|
|
|
|
|
|
Pass the new fields along from the old dictionary. Drop
|
|
|
|
|
|
ctf_dtnextid and ctf_dtbyname. Use ctf_strraw, not dtd_name.
|
|
|
|
|
|
Do not zero out the DTD's ctt_name.
|
|
|
|
|
|
(ctf_prefixed_name): Rename to...
|
|
|
|
|
|
(ctf_name_table): ... this. No longer return a prefixed name: return
|
|
|
|
|
|
the applicable name table instead.
|
|
|
|
|
|
(ctf_dtd_insert): Use it, and use the right name table. Pass in the
|
|
|
|
|
|
kind we're adding. Migrate away from dtd_name.
|
|
|
|
|
|
(ctf_dtd_delete): Adjust similarly. Remove the ref to the
|
|
|
|
|
|
deleted ctt_name.
|
|
|
|
|
|
(ctf_dtd_lookup_type_by_name): Remove.
|
|
|
|
|
|
(ctf_dynamic_type): Always return NULL on read-only dictionaries.
|
|
|
|
|
|
No longer check ctf_dtnextid: check ctf_typemax instead.
|
|
|
|
|
|
(ctf_snapshot): No longer use ctf_dtnextid: use ctf_typemax instead.
|
|
|
|
|
|
(ctf_rollback): Likewise. No longer fail with ECTF_OVERROLLBACK. Use
|
|
|
|
|
|
ctf_name_table and the right name table, and migrate away from
|
|
|
|
|
|
dtd_name as in ctf_dtd_delete.
|
|
|
|
|
|
(ctf_add_generic): Pass in the kind explicitly and pass it to
|
|
|
|
|
|
ctf_dtd_insert. Use ctf_typemax, not ctf_dtnextid. Migrate away
|
|
|
|
|
|
from dtd_name to using ctf_str_add_ref to populate the ctt_name.
|
|
|
|
|
|
Grow the ptrtab if needed.
|
|
|
|
|
|
(ctf_add_encoded): Pass in the kind.
|
|
|
|
|
|
(ctf_add_slice): Likewise.
|
|
|
|
|
|
(ctf_add_array): Likewise.
|
|
|
|
|
|
(ctf_add_function): Likewise.
|
|
|
|
|
|
(ctf_add_typedef): Likewise.
|
|
|
|
|
|
(ctf_add_reftype): Likewise. Initialize the ctf_ptrtab, checking
|
|
|
|
|
|
ctt_name rather than dtd_name.
|
|
|
|
|
|
(ctf_add_struct_sized): Pass in the kind. Use
|
|
|
|
|
|
ctf_lookup_by_rawname, not ctf_hash_lookup_type /
|
|
|
|
|
|
ctf_dtd_lookup_type_by_name.
|
|
|
|
|
|
(ctf_add_union_sized): Likewise.
|
|
|
|
|
|
(ctf_add_enum): Likewise.
|
|
|
|
|
|
(ctf_add_enum_encoded): Likewise.
|
|
|
|
|
|
(ctf_add_forward): Likewise.
|
|
|
|
|
|
(ctf_add_type): Likewise.
|
|
|
|
|
|
(ctf_compress_write): Call ctf_serialize: adjust for ctf_size not
|
|
|
|
|
|
being initialized until after the call.
|
|
|
|
|
|
(ctf_write_mem): Likewise.
|
|
|
|
|
|
(ctf_write): Likewise.
|
|
|
|
|
|
* ctf-archive.c (arc_write_one_ctf): Likewise.
|
|
|
|
|
|
* ctf-lookup.c (ctf_lookup_by_name): Use ctf_lookuup_by_rawhash, not
|
|
|
|
|
|
ctf_hash_lookup_type.
|
|
|
|
|
|
(ctf_lookup_by_id): No longer check the readonly types if the
|
|
|
|
|
|
dictionary is writable.
|
|
|
|
|
|
* ctf-open.c (init_types): Assert that this dictionary is not
|
|
|
|
|
|
writable. Adjust to use the new name hashes, ctf_name_table,
|
|
|
|
|
|
and ctf_ptrtab_len. GNU style fix for the final ptrtab scan.
|
|
|
|
|
|
(ctf_bufopen_internal): New 'writable' parameter. Flip on LCTF_RDWR
|
|
|
|
|
|
if set. Drop out early when dictionary is writable. Split the
|
|
|
|
|
|
ctf_lookups initialization into...
|
|
|
|
|
|
(ctf_set_cth_hashes): ... this new function.
|
|
|
|
|
|
(ctf_simple_open_internal): Adjust. New 'writable' parameter.
|
|
|
|
|
|
(ctf_simple_open): Adjust accordingly.
|
|
|
|
|
|
(ctf_bufopen): Likewise.
|
|
|
|
|
|
(ctf_file_close): Destroy the appropriate name hashes. No longer
|
|
|
|
|
|
destroy ctf_dtbyname, which is gone.
|
|
|
|
|
|
(ctf_getdatasect): Remove spurious "extern".
|
|
|
|
|
|
* ctf-types.c (ctf_lookup_by_rawname): New, look up types in the
|
|
|
|
|
|
specified name table, given a kind.
|
|
|
|
|
|
(ctf_lookup_by_rawhash): Likewise, given a ctf_names_t *.
|
|
|
|
|
|
(ctf_member_iter): Add support for iterating over the
|
|
|
|
|
|
dynamic type list.
|
|
|
|
|
|
(ctf_enum_iter): Likewise.
|
|
|
|
|
|
(ctf_variable_iter): Likewise.
|
|
|
|
|
|
(ctf_type_rvisit): Likewise.
|
|
|
|
|
|
(ctf_member_info): Add support for types in the dynamic type list.
|
|
|
|
|
|
(ctf_enum_name): Likewise.
|
|
|
|
|
|
(ctf_enum_value): Likewise.
|
|
|
|
|
|
(ctf_func_type_info): Likewise.
|
|
|
|
|
|
(ctf_func_type_args): Likewise.
|
|
|
|
|
|
* ctf-link.c (ctf_accumulate_archive_names): No longer call
|
|
|
|
|
|
ctf_update.
|
|
|
|
|
|
(ctf_link_write): Likewise.
|
|
|
|
|
|
(ctf_link_intern_extern_string): Adjust for new
|
|
|
|
|
|
ctf_str_add_external return value.
|
|
|
|
|
|
(ctf_link_add_strtab): Likewise.
|
|
|
|
|
|
* ctf-util.c (ctf_list_empty_p): New.
|
|
|
|
|
|
|
libctf: handle nonrepresentable types at link time
GCC can emit references to type 0 to indicate that this type is one that
is not representable in the version of CTF it emits (for instance,
version 3 cannot encode vector types). Type 0 is already used in the
function section to indicate padding inserted to skip functions we do
not want to encode the type of, so using zero in this way is a good
extension of the format: but libctf reports such types as ECTF_BADID,
which is indistinguishable from file corruption via links to truly
nonexistent types with IDs like 0xDEADBEEF etc, which we really do want
to stop for.
In particular, this stops all traversals of types dead at this point,
preventing us from even dumping CTF files containing unrepresentable
types to see what's going on!
So add a new error, ECTF_NONREPRESENTABLE, which is returned by
recursive type resolution when a reference to a zero type is found. (No
zero type is ever emitted into the CTF file by GCC, only references to
one). We can't do much with types that are ultimately nonrepresentable,
but we can do enough to keep functioning.
Adjust ctf_add_type to ensure that top-level types of type zero and
structure and union members of ultimate type zero are simply skipped
without reporting an error, so we can copy structures and unions that
contain nonrepresentable members (skipping them and leaving a hole where
they would be, so no consumers downstream of the linker need to worry
about this): adjust the dumper so that we dump members of
nonrepresentable types in a simple form that indicates
nonrepresentability rather than terminating the dump, and do not falsely
assume all errors to be -ENOMEM: adjust the linker so that types that
fail to get added are simply skipped, so that both nonrepresentable
types and outright errors do not terminate the type addition, which
could skip many valid types and cause further errors when variables of
those types are added.
In future, when we gain the ability to call back to the linker to report
link-time type resolution errors, we should report failures to add all
but nonrepresentable types. But we can't do that yet.
v5: Fix tabdamage.
include/
* ctf-api.h (ECTF_NONREPRESENTABLE): New.
libctf/
* ctf-types.c (ctf_type_resolve): Return ECTF_NONREPRESENTABLE on
type zero.
* ctf-create.c (ctf_add_type): Detect and skip nonrepresentable
members and types.
(ctf_add_variable): Likewise for variables pointing to them.
* ctf-link.c (ctf_link_one_type): Do not warn for nonrepresentable
type link failure, but do warn for others.
* ctf-dump.c (ctf_dump_format_type): Likewise. Do not assume all
errors to be ENOMEM.
(ctf_dump_member): Likewise.
(ctf_dump_type): Likewise.
(ctf_dump_header_strfield): Do not assume all errors to be ENOMEM.
(ctf_dump_header_sectfield): Do not assume all errors to be ENOMEM.
(ctf_dump_header): Likewise.
(ctf_dump_label): likewise.
(ctf_dump_objts): likewise.
(ctf_dump_funcs): likewise.
(ctf_dump_var): likewise.
(ctf_dump_str): Likewise.
2019-08-05 18:40:33 +08:00
|
|
|
|
2019-08-05 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_resolve): Return ECTF_NONREPRESENTABLE on
|
|
|
|
|
|
type zero.
|
|
|
|
|
|
* ctf-create.c (ctf_add_type): Detect and skip nonrepresentable
|
|
|
|
|
|
members and types.
|
|
|
|
|
|
(ctf_add_variable): Likewise for variables pointing to them.
|
|
|
|
|
|
* ctf-link.c (ctf_link_one_type): Do not warn for nonrepresentable
|
|
|
|
|
|
type link failure, but do warn for others.
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_format_type): Likewise. Do not assume all
|
|
|
|
|
|
errors to be ENOMEM.
|
|
|
|
|
|
(ctf_dump_member): Likewise.
|
|
|
|
|
|
(ctf_dump_type): Likewise.
|
|
|
|
|
|
(ctf_dump_header_strfield): Do not assume all errors to be ENOMEM.
|
|
|
|
|
|
(ctf_dump_header_sectfield): Do not assume all errors to be ENOMEM.
|
|
|
|
|
|
(ctf_dump_header): Likewise.
|
|
|
|
|
|
(ctf_dump_label): likewise.
|
|
|
|
|
|
(ctf_dump_objts): likewise.
|
|
|
|
|
|
(ctf_dump_funcs): likewise.
|
|
|
|
|
|
(ctf_dump_var): likewise.
|
|
|
|
|
|
(ctf_dump_str): Likewise.
|
|
|
|
|
|
|
libctf: installable libctf as a shared library
This lets other programs read and write CTF-format data.
Two versioned shared libraries are created: libctf.so and
libctf-nobfd.so. They contain identical content except that
libctf-nobfd.so contains no references to libbfd and does not implement
ctf_open, ctf_fdopen, ctf_bfdopen or ctf_bfdopen_ctfsect, so it can be
used by programs that cannot use BFD, like readelf.
The soname major version is presently .0 until the linker API
stabilizes, when it will flip to .1 and hopefully never change again.
New in v3.
v4: libtoolize and turn into a pair of shared libraries. Drop
--enable-install-ctf: now controlled by --enable-shared and
--enable-install-libbfd, like everything else.
v5: Add ../bfd to ACLOCAL_AMFLAGS and AC_CONFIG_MACRO_DIR. Fix tabdamage.
* Makefile.def (host_modules): libctf is no longer no_install.
* Makefile.in: Regenerated.
libctf/
* configure.ac (AC_DISABLE_SHARED): New, like opcodes/.
(LT_INIT): Likewise.
(AM_INSTALL_LIBBFD): Likewise.
(dlopen): Note why this is necessary in a comment.
(SHARED_LIBADD): Initialize for possibly-PIC libiberty: derived from
opcodes/.
(SHARED_LDFLAGS): Likewise.
(BFD_LIBADD): Likewise, for libbfd.
(BFD_DEPENDENCIES): Likewise.
(VERSION_FLAGS): Initialize, using a version script if ld supports
one, or libtool -export-symbols-regex otherwise.
(AC_CONFIG_MACRO_DIR): Add ../BFD.
* Makefile.am (ACLOCAL_AMFLAGS): Likewise.
(INCDIR): New.
(AM_CPPFLAGS): Use $(srcdir), not $(top_srcdir).
(noinst_LIBRARIES): Replace with...
[INSTALL_LIBBFD] (lib_LTLIBRARIES): This, or...
[!INSTALL_LIBBFD] (noinst_LTLIBRARIES): ... this, mentioning new
libctf-nobfd.la as well.
[INSTALL_LIBCTF] (include_HEADERS): Add the CTF headers.
[!INSTALL_LIBCTF] (include_HEADERS): New, empty.
(libctf_a_SOURCES): Rename to...
(libctf_nobfd_la_SOURCES): ... this, all of libctf other than
ctf-open-bfd.c.
(libctf_la_SOURCES): Now derived from libctf_nobfd_la_SOURCES,
with ctf-open-bfd.c added.
(libctf_nobfd_la_LIBADD): New, using @SHARED_LIBADD@.
(libctf_la_LIBADD): New, using @BFD_LIBADD@ as well.
(libctf_la_DEPENDENCIES): New, using @BFD_DEPENDENCIES@.
* Makefile.am [INSTALL_LIBCTF]: Use it.
* aclocal.m4: Add ../bfd/acinclude.m4, ../config/acx.m4, and the
libtool macros.
* libctf.ver: New, everything is version LIBCTF_1.0 currently (even
the unstable components).
* Makefile.in: Regenerated.
* config.h.in: Likewise.
* configure: Likewise.
binutils/
* Makefile.am (LIBCTF): Mention the .la file.
(LIBCTF_NOBFD): New.
(readelf_DEPENDENCIES): Use it.
(readelf_LDADD): Likewise.
* Makefile.in: Regenerated.
ld/
* configure.ac (TESTCTFLIB): Set to the .so or .a, like TESTBFDLIB.
* Makefile.am (TESTCTFLIB): Use it.
(LIBCTF): Use the .la file.
(check-DEJAGNU): Use it.
* Makefile.in: Regenerated.
* configure: Likewise.
include/
* ctf-api.h: Note the instability of the ctf_link interfaces.
2019-07-20 21:45:12 +08:00
|
|
|
|
2019-09-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.ac (AC_DISABLE_SHARED): New, like opcodes/.
|
|
|
|
|
|
(LT_INIT): Likewise.
|
|
|
|
|
|
(AM_INSTALL_LIBBFD): Likewise.
|
|
|
|
|
|
(dlopen): Note why this is necessary in a comment.
|
|
|
|
|
|
(SHARED_LIBADD): Initialize for possibly-PIC libiberty: derived from
|
|
|
|
|
|
opcodes/.
|
|
|
|
|
|
(SHARED_LDFLAGS): Likewise.
|
|
|
|
|
|
(BFD_LIBADD): Likewise, for libbfd.
|
|
|
|
|
|
(BFD_DEPENDENCIES): Likewise.
|
|
|
|
|
|
(VERSION_FLAGS): Initialize, using a version script if ld supports
|
|
|
|
|
|
one, or libtool -export-symbols-regex otherwise.
|
|
|
|
|
|
(AC_CONFIG_MACRO_DIR): Add ../BFD.
|
|
|
|
|
|
* Makefile.am (ACLOCAL_AMFLAGS): Likewise.
|
|
|
|
|
|
(INCDIR): New.
|
|
|
|
|
|
(AM_CPPFLAGS): Use $(srcdir), not $(top_srcdir).
|
|
|
|
|
|
(noinst_LIBRARIES): Replace with...
|
|
|
|
|
|
[INSTALL_LIBBFD] (lib_LTLIBRARIES): This, or...
|
|
|
|
|
|
[!INSTALL_LIBBFD] (noinst_LTLIBRARIES): ... this, mentioning new
|
|
|
|
|
|
libctf-nobfd.la as well.
|
|
|
|
|
|
[INSTALL_LIBCTF] (include_HEADERS): Add the CTF headers.
|
|
|
|
|
|
[!INSTALL_LIBCTF] (include_HEADERS): New, empty.
|
|
|
|
|
|
(libctf_a_SOURCES): Rename to...
|
|
|
|
|
|
(libctf_nobfd_la_SOURCES): ... this, all of libctf other than
|
|
|
|
|
|
ctf-open-bfd.c.
|
|
|
|
|
|
(libctf_la_SOURCES): Now derived from libctf_nobfd_la_SOURCES,
|
|
|
|
|
|
with ctf-open-bfd.c added.
|
|
|
|
|
|
(libctf_nobfd_la_LIBADD): New, using @SHARED_LIBADD@.
|
|
|
|
|
|
(libctf_la_LIBADD): New, using @BFD_LIBADD@ as well.
|
|
|
|
|
|
(libctf_la_DEPENDENCIES): New, using @BFD_DEPENDENCIES@.
|
|
|
|
|
|
* Makefile.am [INSTALL_LIBCTF]: Use it.
|
|
|
|
|
|
* aclocal.m4: Add ../bfd/acinclude.m4, ../config/acx.m4, and the
|
|
|
|
|
|
libtool macros.
|
|
|
|
|
|
* libctf.ver: New, everything is version LIBCTF_1.0 currently (even
|
|
|
|
|
|
the unstable components).
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* config.h.in: Likewise.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.ac (INSTALL_LIBCTF): New, controlled by
|
|
|
|
|
|
--enable-install-libctf.
|
|
|
|
|
|
[INSTALL_LIBCTF] (lib_LIBRARIES): Add libctf.a.
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* configure: Regenerated.
|
|
|
|
|
|
|
2019-07-30 00:02:48 +08:00
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_close): Call ctfi_bfd_close if set.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_bfdclose): Fix comment.
|
|
|
|
|
|
|
2019-07-27 04:52:11 +08:00
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_fdopen): Call bfd_set_cacheable.
|
|
|
|
|
|
|
2019-07-14 04:45:55 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (includes): Include <sys/param.h> here.
|
|
|
|
|
|
|
2019-07-26 02:59:32 +08:00
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (flip_lbls): Eschew for-loop initial declarations.
|
|
|
|
|
|
(flip_objts): Likewise.
|
|
|
|
|
|
(flip_vars): Likewise.
|
|
|
|
|
|
(flip_types): Likewise.
|
|
|
|
|
|
|
2019-07-24 22:21:56 +08:00
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c (ctf_hashtab_insert): Pass in the key and value
|
|
|
|
|
|
freeing functions: if set, free the key and value if the slot
|
|
|
|
|
|
already exists. Always reassign the key.
|
|
|
|
|
|
(ctf_dynhash_insert): Adjust call appropriately.
|
|
|
|
|
|
(ctf_hash_insert_type): Likewise.
|
|
|
|
|
|
|
libctf: teach ctf_add_type how forwards work
This machinery has been broken for as long as Solaris has existed.
Forwards are meant to encode "struct foo;", "enum foo;" or "union
foo;". Obviously these all exist in distinct namespaces, so forwards
store the type kind they forward to in their ctt_type member
(which makes conceptual sense if you squint at it). The addition
machinery uses this to promote forwards to the appropriate type as
needed.
Unfortunately ctf_add_type does not: it checks the global namespace
(which is always wrong), and so fails with a spurious conflict if you
have, say, a typedef and then a forward comes along with the same name,
even if it's a forward to something like a struct. (This was observed
with <libio.h>, which has "struct _IO_FILE;" and also
"typedef struct _IO_FILE _IO_FILE"). We should look at the recorded
type kind and look in the appropriate namespace. We should also,
when creating the forward in the new container, use that type kind,
rather than just defaulting to CTF_K_STRUCT and hoping that what
eventually comes along is a struct.
This bug is as old as the first implementation of ctf_add_type in
Solaris. But we also want a new feature for the linker, closely-related
and touching the same code so we add it here: not only do we want a
forward followed by a struct/union/enum to promote the forward, but
we want want a struct/union/enum followed by a forward to act as a NOP
and return the existing type, because when we're adding many files
in succession to a target link, there will often be already-promoted
forwards (in the shape of a struct/union/enum) that want to unify
with duplicate forwards coming from other object files.
v5: fix tabdamage.
libctf/
* ctf-create.c (ctf_add_type): Look up and use the forwarded-to
type kind. Allow forwards to unify with pre-existing structs/
unions/enums.
2019-08-03 07:46:01 +08:00
|
|
|
|
2019-08-03 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_type): Look up and use the forwarded-to
|
|
|
|
|
|
type kind. Allow forwards to unify with pre-existing structs/
|
|
|
|
|
|
unions/enums.
|
|
|
|
|
|
|
libctf: add CU-mapping machinery
Once the deduplicator is capable of actually detecting conflicting types
with the same name (i.e., not yet) we will place such conflicting types,
and types that depend on them, into CTF dictionaries that are the child
of the main dictionary we usually emit: currently, this will lead to the
.ctf section becoming a CTF archive rather than a single dictionary,
with the default-named archive member (_CTF_SECTION, or NULL) being the
main shared dictionary with most of the types in it.
By default, the sections are named after the compilation unit they come
from (complete path and all), with the cuname field in the CTF header
providing further evidence of the name without requiring the caller to
engage in tiresome parsing. But some callers may not wish the mapping
from input CU to output sub-dictionary to be purely CU-based.
The machinery here allows this to be freely changed, in two ways:
- callers can call ctf_link_add_cu_mapping to specify that a single
input compilation unit should have its types placed in some other CU
if they conflict: the CU will always be created, even if empty, so
the consuming program can depend on its existence. You can map
multiple input CUs to one output CU to force all their types to be
merged together: if some of *those* types conflict, the behaviour is
currently unspecified (the new deduplicator will specify it).
- callers can call ctf_link_set_memb_name_changer to provide a function
which is passed every CTF sub-dictionary name in turn (including
_CTF_SECTION) and can return a new name, or NULL if no change is
desired. The mapping from input to output names should not map two
input names to the same output name: if this happens, the two are not
merged but will result in an archive with two members with the same
name (technically valid, but it's hard to access the second
same-named member: you have to do an iteration over archive members).
This is used by the kernel's ctfarchive machinery (not yet upstream) to
encode CTF under member names like {module name}.ctf rather than
.ctf.CU, but it is anticipated that other large projects may wish to
have their own storage for CTF outside of .ctf sections and may wish to
have new naming schemes that suit their special-purpose consumers.
New in v3.
v4: check for strdup failure.
v5: fix tabdamage.
include/
* ctf-api.h (ctf_link_add_cu_mapping): New.
(ctf_link_memb_name_changer_f): New.
(ctf_link_set_memb_name_changer): New.
libctf/
* ctf-impl.h (ctf_file_t) <ctf_link_cu_mappping>: New.
<ctf_link_memb_name_changer>: Likewise.
<ctf_link_memb_name_changer_arg>: Likewise.
* ctf-create.c (ctf_update): Update accordingly.
* ctf-open.c (ctf_file_close): Likewise.
* ctf-link.c (ctf_create_per_cu): Apply the cu mapping.
(ctf_link_add_cu_mapping): New.
(ctf_link_set_memb_name_changer): Likewise.
(ctf_change_parent_name): New.
(ctf_name_list_accum_cb_arg_t) <dynames>: New, storage for names
allocated by the caller's ctf_link_memb_name_changer.
<ndynames>: Likewise.
(ctf_accumulate_archive_names): Call the ctf_link_memb_name_changer.
(ctf_link_write): Likewise (for _CTF_SECTION only): also call
ctf_change_parent_name. Free any resulting names.
2019-07-20 21:44:44 +08:00
|
|
|
|
2019-07-30 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t) <ctf_link_cu_mappping>: New.
|
|
|
|
|
|
<ctf_link_memb_name_changer>: Likewise.
|
|
|
|
|
|
<ctf_link_memb_name_changer_arg>: Likewise.
|
|
|
|
|
|
* ctf-create.c (ctf_update): Update accordingly.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Likewise.
|
|
|
|
|
|
* ctf-link.c (ctf_create_per_cu): Apply the cu mapping.
|
|
|
|
|
|
(ctf_link_add_cu_mapping): New.
|
|
|
|
|
|
(ctf_link_set_memb_name_changer): Likewise.
|
|
|
|
|
|
(ctf_change_parent_name): New.
|
|
|
|
|
|
(ctf_name_list_accum_cb_arg_t) <dynames>: New, storage for names
|
|
|
|
|
|
allocated by the caller's ctf_link_memb_name_changer.
|
|
|
|
|
|
<ndynames>: Likewise.
|
|
|
|
|
|
(ctf_accumulate_archive_names): Call the ctf_link_memb_name_changer.
|
|
|
|
|
|
(ctf_link_write): Likewise (for _CTF_SECTION only): also call
|
|
|
|
|
|
ctf_change_parent_name. Free any resulting names.
|
|
|
|
|
|
|
2019-07-14 04:41:25 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c (ctf_create_per_cu): New, refactored out of...
|
|
|
|
|
|
(ctf_link_one_type): ... here, with parent-name setting added.
|
|
|
|
|
|
(check_variable): New.
|
|
|
|
|
|
(ctf_link_one_variable): Likewise.
|
|
|
|
|
|
(ctf_link_one_input_archive_member): Call it.
|
|
|
|
|
|
* ctf-error.c (_ctf_errlist): Updated with new errors.
|
|
|
|
|
|
|
2019-07-14 04:31:26 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t): New field ctf_link_type_mapping.
|
|
|
|
|
|
(struct ctf_link_type_mapping_key): New.
|
|
|
|
|
|
(ctf_hash_type_mapping_key): Likewise.
|
|
|
|
|
|
(ctf_hash_eq_type_mapping_key): Likewise.
|
|
|
|
|
|
(ctf_add_type_mapping): Likewise.
|
|
|
|
|
|
(ctf_type_mapping): Likewise.
|
|
|
|
|
|
(ctf_dynhash_empty): Likewise.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Update accordingly.
|
|
|
|
|
|
* ctf-create.c (ctf_update): Likewise.
|
|
|
|
|
|
(ctf_add_type): Populate the mapping.
|
|
|
|
|
|
* ctf-hash.c (ctf_hash_type_mapping_key): Hash a type mapping key.
|
|
|
|
|
|
(ctf_hash_eq_type_mapping_key): Check the key for equality.
|
|
|
|
|
|
(ctf_dynhash_insert): Fix comment typo.
|
|
|
|
|
|
(ctf_dynhash_empty): New.
|
|
|
|
|
|
* ctf-link.c (ctf_add_type_mapping): New.
|
|
|
|
|
|
(ctf_type_mapping): Likewise.
|
|
|
|
|
|
(empty_link_type_mapping): New.
|
|
|
|
|
|
(ctf_link_one_input_archive): Call it.
|
|
|
|
|
|
|
libctf: add the ctf_link machinery
This is the start of work on the core of the linking mechanism for CTF
sections. This commit handles the type and string sections.
The linker calls these functions in sequence:
ctf_link_add_ctf: to add each CTF section in the input in turn to a
newly-created ctf_file_t (which will appear in the output, and which
itself will become the shared parent that contains types that all
TUs have in common (in all link modes) and all types that do not
have conflicting definitions between types (by default). Input files
that are themselves products of ld -r are supported, though this is
not heavily tested yet.
ctf_link: called once all input files are added to merge the types in
all the input containers into the output container, eliminating
duplicates.
ctf_link_add_strtab: called once the ELF string table is finalized and
all its offsets are known, this calls a callback provided by the
linker which returns the string content and offset of every string in
the ELF strtab in turn: all these strings which appear in the input
CTF strtab are eliminated from it in favour of the ELF strtab:
equally, any strings that only appear in the input strtab will
reappear in the internal CTF strtab of the output.
ctf_link_shuffle_syms (not yet implemented): called once the ELF symtab
is finalized, this calls a callback provided by the linker which
returns information on every symbol in turn as a ctf_link_sym_t. This
is then used to shuffle the function info and data object sections in
the CTF section into symbol table order, eliminating the index
sections which map those sections to symbol names before that point.
Currently just returns ECTF_NOTYET.
ctf_link_write: Returns a buffer containing either a serialized
ctf_file_t (if there are no types with conflicting definitions in the
object files in the link) or a ctf_archive_t containing a large
ctf_file_t (the common types) and a bunch of small ones named after
individual CUs in which conflicting types are found (containing the
conflicting types, and all types that reference them). A threshold
size above which compression takes place is passed as one parameter.
(Currently, only gzip compression is supported, but I hope to add lzma
as well.)
Lifetime rules for this are simple: don't close the input CTF files
until you've called ctf_link for the last time. We do not assume
that symbols or strings passed in by the callback outlast the
call to ctf_link_add_strtab or ctf_link_shuffle_syms.
Right now, the duplicate elimination mechanism is the one already
present as part of the ctf_add_type function, and is not particularly
good: it misses numerous actual duplicates, and the conflicting-types
detection hardly ever reports that types conflict, even when they do
(one of them just tends to get silently dropped): it is also very slow.
This will all be fixed in the next few weeks, but the fix hardly touches
any of this code, and the linker does work without it, just not as
well as it otherwise might. (And when no CTF section is present,
there is no effect on performance, of course. So only people using
a trunk GCC with not-yet-committed patches will even notice. By the
time it gets upstream, things should be better.)
v3: Fix error handling.
v4: check for strdup failure.
v5: fix tabdamage.
include/
* ctf-api.h (struct ctf_link_sym): New, a symbol in flight to the
libctf linking machinery.
(CTF_LINK_SHARE_UNCONFLICTED): New.
(CTF_LINK_SHARE_DUPLICATED): New.
(ECTF_LINKADDEDLATE): New, replacing ECTF_UNUSED.
(ECTF_NOTYET): New, a 'not yet implemented' message.
(ctf_link_add_ctf): New, add an input file's CTF to the link.
(ctf_link): New, merge the type and string sections.
(ctf_link_strtab_string_f): New, callback for feeding strtab info.
(ctf_link_iter_symbol_f): New, callback for feeding symtab info.
(ctf_link_add_strtab): New, tell the CTF linker about the ELF
strtab's strings.
(ctf_link_shuffle_syms): New, ask the CTF linker to shuffle its
symbols into symtab order.
(ctf_link_write): New, ask the CTF linker to write the CTF out.
libctf/
* ctf-link.c: New file, linking of the string and type sections.
* Makefile.am (libctf_a_SOURCES): Add it.
* Makefile.in: Regenerate.
* ctf-impl.h (ctf_file_t): New fields ctf_link_inputs,
ctf_link_outputs.
* ctf-create.c (ctf_update): Update accordingly.
* ctf-open.c (ctf_file_close): Likewise.
* ctf-error.c (_ctf_errlist): Updated with new errors.
2019-07-14 04:06:55 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-link.c: New file, linking of the string and type sections.
|
|
|
|
|
|
* Makefile.am (libctf_a_SOURCES): Add it.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t): New fields ctf_link_inputs,
|
|
|
|
|
|
ctf_link_outputs.
|
|
|
|
|
|
* ctf-create.c (ctf_update): Update accordingly.
|
|
|
|
|
|
* ctf-open.c (ctf_file_close): Likewise.
|
|
|
|
|
|
* ctf-error.c (_ctf_errlist): Updated with new errors.
|
|
|
|
|
|
|
2019-07-14 03:50:49 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_funcs): Check the right error value.
|
|
|
|
|
|
|
2019-07-14 03:49:19 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump): Use ctf_type_iter_all to dump types, not
|
|
|
|
|
|
ctf_type_iter.
|
|
|
|
|
|
(ctf_dump_type): Pass down the flag from ctf_type_iter_all.
|
|
|
|
|
|
(ctf_dump_format_type): Add non-root-type { } notation.
|
|
|
|
|
|
Add root flag to prototype.
|
|
|
|
|
|
(ctf_dump_label): Adjust accordingly.
|
|
|
|
|
|
(ctf_dump_objts): Likewise.
|
|
|
|
|
|
(ctf_dump_var): Likewise.
|
|
|
|
|
|
|
2019-07-14 03:44:38 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_compress_write): Fix double-free.
|
|
|
|
|
|
|
2019-07-14 03:40:52 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_write): Split off, and reimplement in terms
|
|
|
|
|
|
of...
|
|
|
|
|
|
(ctf_arc_write_fd): ... this new function.
|
|
|
|
|
|
* ctf-create.c (ctf_write_mem): New.
|
|
|
|
|
|
|
libctf: support getting strings from the ELF strtab
The CTF file format has always supported "external strtabs", which
internally are strtab offsets with their MSB on: such refs
get their strings from the strtab passed in at CTF file open time:
this is usually intended to be the ELF strtab, and that's what this
implementation is meant to support, though in theory the external
strtab could come from anywhere.
This commit adds support for these external strings in the ctf-string.c
strtab tracking layer. It's quite easy: we just add a field csa_offset
to the atoms table that tracks all strings: this field tracks the offset
of the string in the ELF strtab (with its MSB already on, courtesy of a
new macro CTF_SET_STID), and adds a new function that sets the
csa_offset to the specified offset (plus MSB). Then we just need to
avoid writing out strings to the internal strtab if they have csa_offset
set, and note that the internal strtab is shorter than it might
otherwise be.
(We could in theory save a little more time here by eschewing sorting
such strings, since we never actually write the strings out anywhere,
but that would mean storing them separately and it's just not worth the
complexity cost until profiling shows it's worth doing.)
We also have to go through a bit of extra effort at variable-sorting
time. This was previously using direct references to the internal
strtab: it couldn't use ctf_strptr or ctf_strraw because the new strtab
is not yet ready to put in its usual field (in a ctf_file_t that hasn't
even been allocated yet at this stage): but now we're using the external
strtab, this will no longer do because it'll be looking things up in the
wrong strtab, with disastrous results. Instead, pass the new internal
strtab in to a new ctf_strraw_explicit function which is just like
ctf_strraw except you can specify a ne winternal strtab to use.
But even now that it is using a new internal strtab, this is not quite
enough: it can't look up strings in the external strtab because ld
hasn't written it out yet, and when it does will write it straight to
disk. Instead, when we write the internal strtab, note all the offset
-> string mappings that we have noted belong in the *external* strtab to
a new "synthetic external strtab" dynhash, ctf_syn_ext_strtab, and look
in there at ctf_strraw time if it is set. This uses minimal extra
memory (because only strings in the external strtab that we actually use
are stored, and even those come straight out of the atoms table), but
let both variable sorting and name interning when ctf_bufopen is next
called work fine. (This also means that we don't need to filter out
spurious ECTF_STRTAB warnings from ctf_bufopen but can pass them back to
the caller, once we wrap ctf_bufopen so that we have a new internal
variant of ctf_bufopen etc that we can pass the synthetic external
strtab to. That error has been filtered out since the days of Solaris
libctf, which didn't try to handle the problem of getting external
strtabs right at construction time at all.)
v3: add the synthetic strtab and all associated machinery.
v5: fix tabdamage.
include/
* ctf.h (CTF_SET_STID): New.
libctf/
* ctf-impl.h (ctf_str_atom_t) <csa_offset>: New field.
(ctf_file_t) <ctf_syn_ext_strtab>: Likewise.
(ctf_str_add_ref): Name the last arg.
(ctf_str_add_external) New.
(ctf_str_add_strraw_explicit): Likewise.
(ctf_simple_open_internal): Likewise.
(ctf_bufopen_internal): Likewise.
* ctf-string.c (ctf_strraw_explicit): Split from...
(ctf_strraw): ... here, with new support for ctf_syn_ext_strtab.
(ctf_str_add_ref_internal): Return the atom, not the
string.
(ctf_str_add): Adjust accordingly.
(ctf_str_add_ref): Likewise. Move up in the file.
(ctf_str_add_external): New: update the csa_offset.
(ctf_str_count_strtab): Only account for strings with no csa_offset
in the internal strtab length.
(ctf_str_write_strtab): If the csa_offset is set, update the
string's refs without writing the string out, and update the
ctf_syn_ext_strtab. Make OOM handling less ugly.
* ctf-create.c (struct ctf_sort_var_arg_cb): New.
(ctf_update): Handle failure to populate the strtab. Pass in the
new ctf_sort_var arg. Adjust for ctf_syn_ext_strtab addition.
Call ctf_simple_open_internal, not ctf_simple_open.
(ctf_sort_var): Call ctf_strraw_explicit rather than looking up
strings by hand.
* ctf-hash.c (ctf_hash_insert_type): Likewise (but using
ctf_strraw). Adjust to diagnose ECTF_STRTAB nonetheless.
* ctf-open.c (init_types): No longer filter out ECTF_STRTAB.
(ctf_file_close): Destroy the ctf_syn_ext_strtab.
(ctf_simple_open): Rename to, and reimplement as a wrapper around...
(ctf_simple_open_internal): ... this new function, which calls
ctf_bufopen_internal.
(ctf_bufopen): Rename to, and reimplement as a wrapper around...
(ctf_bufopen_internal): ... this new function, which sets
ctf_syn_ext_strtab.
2019-07-14 03:33:01 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_str_atom_t) <csa_offset>: New field.
|
|
|
|
|
|
(ctf_file_t) <ctf_syn_ext_strtab>: Likewise.
|
|
|
|
|
|
(ctf_str_add_ref): Name the last arg.
|
|
|
|
|
|
(ctf_str_add_external) New.
|
|
|
|
|
|
(ctf_str_add_strraw_explicit): Likewise.
|
|
|
|
|
|
(ctf_simple_open_internal): Likewise.
|
|
|
|
|
|
(ctf_bufopen_internal): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-string.c (ctf_strraw_explicit): Split from...
|
|
|
|
|
|
(ctf_strraw): ... here, with new support for ctf_syn_ext_strtab.
|
|
|
|
|
|
(ctf_str_add_ref_internal): Return the atom, not the
|
|
|
|
|
|
string.
|
|
|
|
|
|
(ctf_str_add): Adjust accordingly.
|
|
|
|
|
|
(ctf_str_add_ref): Likewise. Move up in the file.
|
|
|
|
|
|
(ctf_str_add_external): New: update the csa_offset.
|
|
|
|
|
|
(ctf_str_count_strtab): Only account for strings with no csa_offset
|
|
|
|
|
|
in the internal strtab length.
|
|
|
|
|
|
(ctf_str_write_strtab): If the csa_offset is set, update the
|
|
|
|
|
|
string's refs without writing the string out, and update the
|
|
|
|
|
|
ctf_syn_ext_strtab. Make OOM handling less ugly.
|
|
|
|
|
|
* ctf-create.c (struct ctf_sort_var_arg_cb): New.
|
|
|
|
|
|
(ctf_update): Handle failure to populate the strtab. Pass in the
|
|
|
|
|
|
new ctf_sort_var arg. Adjust for ctf_syn_ext_strtab addition.
|
|
|
|
|
|
Call ctf_simple_open_internal, not ctf_simple_open.
|
|
|
|
|
|
(ctf_sort_var): Call ctf_strraw_explicit rather than looking up
|
|
|
|
|
|
strings by hand.
|
|
|
|
|
|
* ctf-hash.c (ctf_hash_insert_type): Likewise (but using
|
|
|
|
|
|
ctf_strraw). Adjust to diagnose ECTF_STRTAB nonetheless.
|
|
|
|
|
|
* ctf-open.c (init_types): No longer filter out ECTF_STRTAB.
|
|
|
|
|
|
(ctf_file_close): Destroy the ctf_syn_ext_strtab.
|
|
|
|
|
|
(ctf_simple_open): Rename to, and reimplement as a wrapper around...
|
|
|
|
|
|
(ctf_simple_open_internal): ... this new function, which calls
|
|
|
|
|
|
ctf_bufopen_internal.
|
|
|
|
|
|
(ctf_bufopen): Rename to, and reimplement as a wrapper around...
|
|
|
|
|
|
(ctf_bufopen_internal): ... this new function, which sets
|
|
|
|
|
|
ctf_syn_ext_strtab.
|
|
|
|
|
|
|
2019-07-14 03:00:07 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf_types.c (ctf_type_iter_all): New.
|
|
|
|
|
|
|
2019-07-11 23:21:26 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (init_symtab): Check for overflow against the right
|
|
|
|
|
|
section.
|
|
|
|
|
|
(upgrade_header): Set cth_objtidxoff, cth_funcidxoff to zero-length.
|
|
|
|
|
|
(upgrade_types_v1): Note that these sections are not checked.
|
|
|
|
|
|
(flip_header): Endian-swap the header fields.
|
|
|
|
|
|
(flip_ctf): Endian-swap the sections.
|
|
|
|
|
|
(flip_objts): Update comment.
|
|
|
|
|
|
(ctf_bufopen): Check header offsets and alignment for validity.
|
|
|
|
|
|
|
libctf, bfd: fix ctf_bfdopen_ctfsect opening symbol and string sections
The code in ctf_bfdopen_ctfsect (which is the ultimate place where you
end up if you use ctf_open to open a CTF file and pull in the ELF string
and symbol tables) was written before it was possible to actually test
it, since the linker was not written. Now it is, it turns out that the
previous code was completely nonfunctional: it assumed that you could
load the symbol table via bfd_section_from_elf_index (...,elf_onesymtab())
and the string table via bfd_section_from_elf_index on the sh_link.
Unfortunately BFD loads neither of these sections in the conventional
fashion it uses for most others: the symbol table is immediately
converted into internal form (which is useless for our purposes, since
we also have to work in the absence of BFD for readelf, etc) and the
string table is loaded specially via bfd_elf_get_str_section which is
private to bfd/elf.c.
So make this function public, export it in elf-bfd.h, and use it from
libctf, which does something similar to what bfd_elf_sym_name and
bfd_elf_string_from_elf_section do. Similarly, load the symbol table
manually using bfd_elf_get_elf_syms and throw away the internal form
it generates for us (we never use it).
BFD allocates the strtab for us via bfd_alloc, so we can leave BFD to
deallocate it: we allocate the symbol table ourselves before calling
bfd_elf_get_elf_syms, so we still have to free it.
Also change the rules around what you are allowed to provide: It is
useful to provide a string section but no symbol table, because CTF
sections can legitimately have no function info or data object sections
while relying on the ELF strtab for some of their strings. So allow
that combination.
v4: adjust to upstream changes. ctf_bfdopen_ctfsect's first parameter
is potentially unused again (if BFD is not in use for this link
due to not supporting an ELF target).
v5: fix tabdamage.
bfd/
* elf-bfd.h (bfd_elf_get_str_section): Add.
* elf.c (bfd_elf_get_str_section): No longer static.
libctf/
* ctf-open-bfd.c: Add <assert.h>.
(ctf_bfdopen_ctfsect): Open string and symbol tables using
techniques borrowed from bfd_elf_sym_name.
(ctf_new_archive_internal): Improve comment.
* ctf-archive.c (ctf_arc_close): Do not free the ctfi_strsect.
* ctf-open.c (ctf_bufopen): Allow opening with a string section but
no symbol section, but not vice versa.
2019-07-11 23:26:54 +08:00
|
|
|
|
2019-07-13 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open-bfd.c: Add <assert.h>.
|
|
|
|
|
|
(ctf_bfdopen_ctfsect): Open string and symbol tables using
|
|
|
|
|
|
techniques borrowed from bfd_elf_sym_name.
|
|
|
|
|
|
(ctf_new_archive_internal): Improve comment.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_close): Do not free the ctfi_strsect.
|
|
|
|
|
|
* ctf-open.c (ctf_bufopen): Allow opening with a string section but
|
|
|
|
|
|
no symbol section, but not vice versa.
|
|
|
|
|
|
|
2019-07-08 20:59:15 +08:00
|
|
|
|
2019-07-08 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t): New field ctf_openflags.
|
|
|
|
|
|
* ctf-open.c (ctf_bufopen): Set it. No longer dump header offsets.
|
|
|
|
|
|
* ctf-dump.c (dump_header): New function, dump the CTF header.
|
|
|
|
|
|
(ctf_dump): Call it.
|
|
|
|
|
|
(ctf_dump_header_strfield): New function.
|
|
|
|
|
|
(ctf_dump_header_sectfield): Likewise.
|
|
|
|
|
|
|
libctf: allow the header to change between versions
libctf supports dynamic upgrading of the type table as file format
versions change, but before now has not supported changes to the CTF
header. Doing this is complicated by the baroque storage method used:
the CTF header is kept prepended to the rest of the CTF data, just as
when read from the file, and written out from there, and is
endian-flipped in place.
This makes accessing it needlessly hard and makes it almost impossible
to make the header larger if we add fields. The general storage
machinery around the malloced ctf pointer (the 'ctf_base') is also
overcomplicated: the pointer is sometimes malloced locally and sometimes
assigned from a parameter, so freeing it requires checking to see if
that parameter was used, needlessly coupling ctf_bufopen and
ctf_file_close together.
So split the header out into a new ctf_file_t.ctf_header, which is
written out explicitly: squeeze it out of the CTF buffer whenever we
reallocate it, and use ctf_file_t.ctf_buf to skip past the header when
we do not need to reallocate (when no upgrading or endian-flipping is
required). We now track whether the CTF base can be freed explicitly
via a new ctf_dynbase pointer which is non-NULL only when freeing is
possible.
With all this done, we can upgrade the header on the fly and add new
fields as desired, via a new upgrade_header function in ctf-open.
As with other forms of upgrading, libctf upgrades older headers
automatically to the latest supported version at open time.
For a first use of this field, we add a new string field cth_cuname, and
a corresponding setter/getter pair ctf_cuname_set and ctf_cuname: this
is used by debuggers to determine whether a CTF section's types relate
to a single compilation unit, or to all compilation units in the
program. (Types with ambiguous definitions in different CUs have only
one of these types placed in the top-level shared .ctf container: the
rest are placed in much smaller per-CU containers, which have the shared
container as their parent. Since CTF must be useful in the absence of
DWARF, we store the names of the relevant CUs ourselves, so the debugger
can look them up.)
v5: fix tabdamage.
include/
* ctf-api.h (ctf_cuname): New function.
(ctf_cuname_set): Likewise.
* ctf.h: Improve comment around upgrading, no longer
implying that v2 is the target of upgrades (it is v3 now).
(ctf_header_v2_t): New, old-format header for backward
compatibility.
(ctf_header_t): Add cth_cuname: this is the first of several
header changes in format v3.
libctf/
* ctf-impl.h (ctf_file_t): New fields ctf_header, ctf_dynbase,
ctf_cuname, ctf_dyncuname: ctf_base and ctf_buf are no longer const.
* ctf-open.c (ctf_set_base): Preserve the gap between ctf_buf and
ctf_base: do not assume that it is always sizeof (ctf_header_t).
Print out ctf_cuname: only print out ctf_parname if set.
(ctf_free_base): Removed, ctf_base is no longer freed: free
ctf_dynbase instead.
(ctf_set_version): Fix spacing.
(upgrade_header): New, in-place header upgrading.
(upgrade_types): Rename to...
(upgrade_types_v1): ... this. Free ctf_dynbase, not ctf_base. No
longer track old and new headers separately. No longer allow for
header sizes explicitly: squeeze the headers out on upgrade (they
are preserved in fp->ctf_header). Set ctf_dynbase, ctf_base and
ctf_buf explicitly. Use ctf_free, not ctf_free_base.
(upgrade_types): New, also handle ctf_parmax updating.
(flip_header): Flip ctf_cuname.
(flip_types): Flip BUF explicitly rather than deriving BUF from
BASE.
(ctf_bufopen): Store the header in fp->ctf_header. Correct minimum
required alignment of objtoff and funcoff. No longer store it in
the ctf_buf unless that buf is derived unmodified from the input.
Set ctf_dynbase where ctf_base is dynamically allocated. Drop locals
that duplicate fields in ctf_file: move allocation of ctf_file
further up instead. Call upgrade_header as needed. Move
version-specific ctf_parmax initialization into upgrade_types. More
concise error handling.
(ctf_file_close): No longer test for null pointers before freeing.
Free ctf_dyncuname, ctf_dynbase, and ctf_header. Do not call
ctf_free_base.
(ctf_cuname): New.
(ctf_cuname_set): New.
* ctf-create.c (ctf_update): Populate ctf_cuname.
(ctf_gzwrite): Write out the header explicitly. Remove obsolescent
comment.
(ctf_write): Likewise.
(ctf_compress_write): Get the header from ctf_header, not ctf_base.
Fix the compression length: fp->ctf_size never counted the CTF
header. Simplify the compress call accordingly.
2019-07-07 00:36:21 +08:00
|
|
|
|
2019-07-06 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_file_t): New fields ctf_header, ctf_dynbase,
|
|
|
|
|
|
ctf_cuname, ctf_dyncuname: ctf_base and ctf_buf are no longer const.
|
|
|
|
|
|
* ctf-open.c (ctf_set_base): Preserve the gap between ctf_buf and
|
|
|
|
|
|
ctf_base: do not assume that it is always sizeof (ctf_header_t).
|
|
|
|
|
|
Print out ctf_cuname: only print out ctf_parname if set.
|
|
|
|
|
|
(ctf_free_base): Removed, ctf_base is no longer freed: free
|
|
|
|
|
|
ctf_dynbase instead.
|
|
|
|
|
|
(ctf_set_version): Fix spacing.
|
|
|
|
|
|
(upgrade_header): New, in-place header upgrading.
|
|
|
|
|
|
(upgrade_types): Rename to...
|
|
|
|
|
|
(upgrade_types_v1): ... this. Free ctf_dynbase, not ctf_base. No
|
|
|
|
|
|
longer track old and new headers separately. No longer allow for
|
|
|
|
|
|
header sizes explicitly: squeeze the headers out on upgrade (they
|
|
|
|
|
|
are preserved in fp->ctf_header). Set ctf_dynbase, ctf_base and
|
|
|
|
|
|
ctf_buf explicitly. Use ctf_free, not ctf_free_base.
|
|
|
|
|
|
(upgrade_types): New, also handle ctf_parmax updating.
|
|
|
|
|
|
(flip_header): Flip ctf_cuname.
|
|
|
|
|
|
(flip_types): Flip BUF explicitly rather than deriving BUF from
|
|
|
|
|
|
BASE.
|
|
|
|
|
|
(ctf_bufopen): Store the header in fp->ctf_header. Correct minimum
|
|
|
|
|
|
required alignment of objtoff and funcoff. No longer store it in
|
|
|
|
|
|
the ctf_buf unless that buf is derived unmodified from the input.
|
|
|
|
|
|
Set ctf_dynbase where ctf_base is dynamically allocated. Drop locals
|
|
|
|
|
|
that duplicate fields in ctf_file: move allocation of ctf_file
|
|
|
|
|
|
further up instead. Call upgrade_header as needed. Move
|
|
|
|
|
|
version-specific ctf_parmax initialization into upgrade_types. More
|
|
|
|
|
|
concise error handling.
|
|
|
|
|
|
(ctf_file_close): No longer test for null pointers before freeing.
|
|
|
|
|
|
Free ctf_dyncuname, ctf_dynbase, and ctf_header. Do not call
|
|
|
|
|
|
ctf_free_base.
|
|
|
|
|
|
(ctf_cuname): New.
|
|
|
|
|
|
(ctf_cuname_set): New.
|
|
|
|
|
|
* ctf-create.c (ctf_update): Populate ctf_cuname.
|
|
|
|
|
|
(ctf_gzwrite): Write out the header explicitly. Remove obsolescent
|
|
|
|
|
|
comment.
|
|
|
|
|
|
(ctf_write): Likewise.
|
|
|
|
|
|
(ctf_compress_write): Get the header from ctf_header, not ctf_base.
|
|
|
|
|
|
Fix the compression length: fp->ctf_size never counted the CTF
|
|
|
|
|
|
header. Simplify the compress call accordingly.
|
|
|
|
|
|
|
libctf: make it compile for old glibc
With a glibc before 2.9 (such as 2.8), there's <endian.h> but no
htole64 or le64toh, so you get, compiling binutils for any target:
libtool: link: gcc -W -Wall -Wstrict-prototypes -Wmissing-prototypes \
-Wshadow -Werror -I/x/binutils/../zlib -g -O2 -o objdump \
objdump.o dwarf.o prdbg.o rddbg.o debug.o stabs.o rdcoff.o \
bucomm.o version.o filemode.o elfcomm.o ../opcodes/.libs/libopcodes.a \
../libctf/libctf.a ../bfd/.libs/libbfd.a -L/x/obj/b/zlib -lz ../libiberty/libiberty.a -ldl
../libctf/libctf.a(ctf-archive.o): In function `ctf_archive_raw_iter_internal':
/x/src/libctf/ctf-archive.c:543: undefined reference to `le64toh'
/x/src/libctf/ctf-archive.c:550: undefined reference to `le64toh'
/x/src/libctf/ctf-archive.c:551: undefined reference to `le64toh'
/x/src/libctf/ctf-archive.c:551: undefined reference to `le64toh'
/x/src/libctf/ctf-archive.c:554: undefined reference to `le64toh'
../libctf/libctf.a(ctf-archive.o):/x/src/libctf/ctf-archive.c:545: more undefined references to `le64toh' follow
(etc)
Also, I see no bswap_identity_64 *anywhere* except in libctf/swap.h
(including current glibc) and I don't think calling an "identity"-
function is better than just plain "#define foo(x) (x)" anyway.
(Where does the idea of a bytestap.h bswap_identity_64 come from?)
Speaking of that, I should mention that I instrumented the condition
to observe that the WORDS_BIGENDIAN case passes too for a presumed
big-endian target and glibc-2.8: there is a bswap_64 present for that
version. Curiously, no test-case regressed with that instrumentation.
For the record, constructing binary blobs using text source to run
tests on, can be done by linking to --oformat binary (with most ELF
targets), but I guess that's seen as unnecessary roundabout perhaps
checking in binary files in the test-suite would be ok these days.
[...]
[nca: trimmed commit log slightly, updated changelog]
v5: fix tabdamage.
libctf/
* ctf-endian.h: Don't assume htole64 and le64toh are always
present if HAVE_ENDIAN_H; also check if htole64 is defined.
[!WORDS_BIGENDIAN] (htole64, le64toh): Define as identity,
not bswap_identity_64.
2019-07-11 12:11:09 +08:00
|
|
|
|
2019-07-11 Hans-Peter Nilsson <hp@bitrange.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-endian.h: Don't assume htole64 and le64toh are always
|
|
|
|
|
|
present if HAVE_ENDIAN_H; also check if htole64 is defined.
|
|
|
|
|
|
[!WORDS_BIGENDIAN] (htole64, le64toh): Define as identity,
|
|
|
|
|
|
not bswap_identity_64.
|
|
|
|
|
|
|
bfd_section_* macros
This large patch removes the unnecessary bfd parameter from various
bfd section macros and functions. The bfd is hardly ever used and if
needed for the bfd_set_section_* or bfd_rename_section functions can
be found via section->owner except for the com, und, abs, and ind
std_section special sections. Those sections shouldn't be modified
anyway.
The patch also removes various bfd_get_section_<field> macros,
replacing their use with bfd_section_<field>, and adds
bfd_set_section_lma. I've also fixed a minor bug in gas where
compressed section renaming was done directly rather than calling
bfd_rename_section. This would have broken bfd_get_section_by_name
and similar functions, but that hardly mattered at such a late stage
in gas processing.
bfd/
* bfd-in.h (bfd_get_section_name, bfd_get_section_vma),
(bfd_get_section_lma, bfd_get_section_alignment),
(bfd_get_section_size, bfd_get_section_flags),
(bfd_get_section_userdata): Delete.
(bfd_section_name, bfd_section_size, bfd_section_vma),
(bfd_section_lma, bfd_section_alignment): Lose bfd parameter.
(bfd_section_flags, bfd_section_userdata): New.
(bfd_is_com_section): Rename parameter.
* section.c (bfd_set_section_userdata, bfd_set_section_vma),
(bfd_set_section_alignment, bfd_set_section_flags, bfd_rename_section),
(bfd_set_section_size): Delete bfd parameter, rename section parameter.
(bfd_set_section_lma): New.
* bfd-in2.h: Regenerate.
* mach-o.c (bfd_mach_o_init_section_from_mach_o): Delete bfd param,
update callers.
* aoutx.h, * bfd.c, * coff-alpha.c, * coff-arm.c, * coff-mips.c,
* coff64-rs6000.c, * coffcode.h, * coffgen.c, * cofflink.c,
* compress.c, * ecoff.c, * elf-eh-frame.c, * elf-hppa.h,
* elf-ifunc.c, * elf-m10200.c, * elf-m10300.c, * elf-properties.c,
* elf-s390-common.c, * elf-vxworks.c, * elf.c, * elf32-arc.c,
* elf32-arm.c, * elf32-avr.c, * elf32-bfin.c, * elf32-cr16.c,
* elf32-cr16c.c, * elf32-cris.c, * elf32-crx.c, * elf32-csky.c,
* elf32-d10v.c, * elf32-epiphany.c, * elf32-fr30.c, * elf32-frv.c,
* elf32-ft32.c, * elf32-h8300.c, * elf32-hppa.c, * elf32-i386.c,
* elf32-ip2k.c, * elf32-iq2000.c, * elf32-lm32.c, * elf32-m32c.c,
* elf32-m32r.c, * elf32-m68hc1x.c, * elf32-m68k.c, * elf32-mcore.c,
* elf32-mep.c, * elf32-metag.c, * elf32-microblaze.c,
* elf32-moxie.c, * elf32-msp430.c, * elf32-mt.c, * elf32-nds32.c,
* elf32-nios2.c, * elf32-or1k.c, * elf32-ppc.c, * elf32-pru.c,
* elf32-rl78.c, * elf32-rx.c, * elf32-s390.c, * elf32-score.c,
* elf32-score7.c, * elf32-sh.c, * elf32-spu.c, * elf32-tic6x.c,
* elf32-tilepro.c, * elf32-v850.c, * elf32-vax.c, * elf32-visium.c,
* elf32-xstormy16.c, * elf32-xtensa.c, * elf64-alpha.c,
* elf64-bpf.c, * elf64-hppa.c, * elf64-ia64-vms.c, * elf64-mmix.c,
* elf64-ppc.c, * elf64-s390.c, * elf64-sparc.c, * elf64-x86-64.c,
* elflink.c, * elfnn-aarch64.c, * elfnn-ia64.c, * elfnn-riscv.c,
* elfxx-aarch64.c, * elfxx-mips.c, * elfxx-sparc.c,
* elfxx-tilegx.c, * elfxx-x86.c, * i386msdos.c, * linker.c,
* mach-o.c, * mmo.c, * opncls.c, * pdp11.c, * pei-x86_64.c,
* peicode.h, * reloc.c, * section.c, * syms.c, * vms-alpha.c,
* xcofflink.c: Update throughout for bfd section macro and function
changes.
binutils/
* addr2line.c, * bucomm.c, * coffgrok.c, * dlltool.c, * nm.c,
* objcopy.c, * objdump.c, * od-elf32_avr.c, * od-macho.c,
* od-xcoff.c, * prdbg.c, * rdcoff.c, * rddbg.c, * rescoff.c,
* resres.c, * size.c, * srconv.c, * strings.c, * windmc.c: Update
throughout for bfd section macro and function changes.
gas/
* as.c, * as.h, * dw2gencfi.c, * dwarf2dbg.c, * ecoff.c,
* read.c, * stabs.c, * subsegs.c, * subsegs.h, * write.c,
* config/obj-coff-seh.c, * config/obj-coff.c, * config/obj-ecoff.c,
* config/obj-elf.c, * config/obj-macho.c, * config/obj-som.c,
* config/tc-aarch64.c, * config/tc-alpha.c, * config/tc-arc.c,
* config/tc-arm.c, * config/tc-avr.c, * config/tc-bfin.c,
* config/tc-bpf.c, * config/tc-d10v.c, * config/tc-d30v.c,
* config/tc-epiphany.c, * config/tc-fr30.c, * config/tc-frv.c,
* config/tc-h8300.c, * config/tc-hppa.c, * config/tc-i386.c,
* config/tc-ia64.c, * config/tc-ip2k.c, * config/tc-iq2000.c,
* config/tc-lm32.c, * config/tc-m32c.c, * config/tc-m32r.c,
* config/tc-m68hc11.c, * config/tc-mep.c, * config/tc-microblaze.c,
* config/tc-mips.c, * config/tc-mmix.c, * config/tc-mn10200.c,
* config/tc-mn10300.c, * config/tc-msp430.c, * config/tc-mt.c,
* config/tc-nds32.c, * config/tc-or1k.c, * config/tc-ppc.c,
* config/tc-pru.c, * config/tc-rl78.c, * config/tc-rx.c,
* config/tc-s12z.c, * config/tc-s390.c, * config/tc-score.c,
* config/tc-score7.c, * config/tc-sh.c, * config/tc-sparc.c,
* config/tc-spu.c, * config/tc-tic4x.c, * config/tc-tic54x.c,
* config/tc-tic6x.c, * config/tc-tilegx.c, * config/tc-tilepro.c,
* config/tc-v850.c, * config/tc-visium.c, * config/tc-wasm32.c,
* config/tc-xc16x.c, * config/tc-xgate.c, * config/tc-xstormy16.c,
* config/tc-xtensa.c, * config/tc-z8k.c: Update throughout for
bfd section macro and function changes.
* write.c (compress_debug): Use bfd_rename_section.
gdb/
* aarch64-linux-tdep.c, * arm-tdep.c, * auto-load.c,
* coff-pe-read.c, * coffread.c, * corelow.c, * dbxread.c,
* dicos-tdep.c, * dwarf2-frame.c, * dwarf2read.c, * elfread.c,
* exec.c, * fbsd-tdep.c, * gcore.c, * gdb_bfd.c, * gdb_bfd.h,
* hppa-tdep.c, * i386-cygwin-tdep.c, * i386-fbsd-tdep.c,
* i386-linux-tdep.c, * jit.c, * linux-tdep.c, * machoread.c,
* maint.c, * mdebugread.c, * minidebug.c, * mips-linux-tdep.c,
* mips-sde-tdep.c, * mips-tdep.c, * mipsread.c, * nto-tdep.c,
* objfiles.c, * objfiles.h, * osabi.c, * ppc-linux-tdep.c,
* ppc64-tdep.c, * record-btrace.c, * record-full.c, * remote.c,
* rs6000-aix-tdep.c, * rs6000-tdep.c, * s390-linux-tdep.c,
* s390-tdep.c, * solib-aix.c, * solib-dsbt.c, * solib-frv.c,
* solib-spu.c, * solib-svr4.c, * solib-target.c,
* spu-linux-nat.c, * spu-tdep.c, * symfile-mem.c, * symfile.c,
* symmisc.c, * symtab.c, * target.c, * windows-nat.c,
* xcoffread.c, * cli/cli-dump.c, * compile/compile-object-load.c,
* mi/mi-interp.c: Update throughout for bfd section macro and
function changes.
* gcore (gcore_create_callback): Use bfd_set_section_lma.
* spu-tdep.c (spu_overlay_new_objfile): Likewise.
gprof/
* corefile.c, * symtab.c: Update throughout for bfd section
macro and function changes.
ld/
* ldcref.c, * ldctor.c, * ldelf.c, * ldlang.c, * pe-dll.c,
* emultempl/aarch64elf.em, * emultempl/aix.em,
* emultempl/armcoff.em, * emultempl/armelf.em,
* emultempl/cr16elf.em, * emultempl/cskyelf.em,
* emultempl/m68hc1xelf.em, * emultempl/m68kelf.em,
* emultempl/mipself.em, * emultempl/mmix-elfnmmo.em,
* emultempl/mmo.em, * emultempl/msp430.em,
* emultempl/nios2elf.em, * emultempl/pe.em, * emultempl/pep.em,
* emultempl/ppc64elf.em, * emultempl/xtensaelf.em: Update
throughout for bfd section macro and function changes.
libctf/
* ctf-open-bfd.c: Update throughout for bfd section macro changes.
opcodes/
* arc-ext.c: Update throughout for bfd section macro changes.
sim/
* common/sim-load.c, * common/sim-utils.c, * cris/sim-if.c,
* erc32/func.c, * lm32/sim-if.c, * m32c/load.c, * m32c/trace.c,
* m68hc11/interp.c, * ppc/hw_htab.c, * ppc/hw_init.c,
* rl78/load.c, * rl78/trace.c, * rx/gdb-if.c, * rx/load.c,
* rx/trace.c: Update throughout for bfd section macro changes.
2019-09-16 18:55:17 +08:00
|
|
|
|
2019-09-18 Alan Modra <amodra@gmail.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open-bfd.c: Update throughout for bfd section macro changes.
|
|
|
|
|
|
|
2019-09-09 17:27:03 +08:00
|
|
|
|
2019-09-09 Phil Blundell <pb@pbcl.net>
|
|
|
|
|
|
|
|
|
|
|
|
binutils 2.33 branch created.
|
|
|
|
|
|
|
2019-07-19 01:44:21 +08:00
|
|
|
|
2019-07-18 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-types.c (ctf_type_aname_raw): New.
|
|
|
|
|
|
(ctf_func_type_info): Likewise.
|
|
|
|
|
|
(ctf_func_type_args): Likewise.
|
|
|
|
|
|
* ctf-error.c (_ctf_errlist): Fix description.
|
|
|
|
|
|
* ctf-lookup.c: Fix file description.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-28 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-29 05:11:14 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_create): Fix off-by-one error.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-28 Nick Alcock <nick.alcock@oracle.com>
|
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.
2019-06-27 20:51:10 +08:00
|
|
|
|
|
|
|
|
|
|
* 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_rollback): 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.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-28 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-27 20:30:22 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (ctf_hash_iter_f): New.
|
|
|
|
|
|
(ctf_dynhash_iter): New declaration.
|
|
|
|
|
|
(ctf_dynhash_iter_remove): New declaration.
|
|
|
|
|
|
* ctf-hash.c (ctf_dynhash_iter): Define.
|
|
|
|
|
|
(ctf_dynhash_iter_remove): Likewise.
|
|
|
|
|
|
(ctf_hashtab_traverse): New.
|
|
|
|
|
|
(ctf_hashtab_traverse_remove): Likewise.
|
|
|
|
|
|
(struct ctf_traverse_cb_arg): Likewise.
|
|
|
|
|
|
(struct ctf_traverse_remove_cb_arg): Likewise.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-28 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-29 04:58:31 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c (ctf_dynhash_remove): Call with a mocked-up element.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-28 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-27 20:15:37 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_format_type): Prefix hex strings with 0x.
|
|
|
|
|
|
(ctf_dump_funcs): Likewise.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
libctf: fix ctf_open endianness problems with raw CTF files
ctf_open (or, rather, ctf_fdopen, which underlies it) has several
endianness problems, even though it was written after the
endian-swapping code was implemented, so should have been endian-aware.
Even though the comment right above the relevant check says that it wil
check for CTF magic in any endianness, it only checks in the native
endianness, so opening raw LE CTF files on BE, or vice-versa, will fail.
It also checks the CTF version by hand, without ever endianness-swapping
the header, so that too will fail, and is entirely redundant because
ctf_simple_open does the job properly in any case. We have a similar
problem in the next if block, which checks for raw CTF archives: we are
checking in the native endianness while we should be doing a le64toh()
on it to check in little-endian form only: so opening CTF archives
created on the local machine will fail if the local machine is
big-endian.
Adding insult to injury, if ctf_simple_open then fails, we go on and try
to turn it into a single-element CTF archive regardless, throwing the
error away. Since this involves dereferencing null pointers it is not
likely to work very well.
libctf/
* ctf-open-bfd.c: Add swap.h and ctf-endian.h.
(ctf_fdopen): Check for endian-swapped raw CTF magic, and
little-endian CTF archive magic. Do not check the CTF version:
ctf_simple_open does that in endian-safe ways. Do not dereference
null pointers on open failure.
2019-06-19 22:56:52 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-open-bfd.c: Add swap.h and ctf-endian.h.
|
|
|
|
|
|
(ctf_fdopen): Check for endian-swapped raw CTF magic, and
|
|
|
|
|
|
little-endian CTF archive magic. Do not check the CTF version:
|
|
|
|
|
|
ctf_simple_open does that in endian-safe ways. Do not dereference
|
|
|
|
|
|
null pointers on open failure.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
libctf: endianness fixes
Testing of the first code to generate CTF_K_SLICEs on big-endian
revealed a bunch of new problems in this area. Most importantly, the
trick we did earlier to avoid wasting two bytes on padding in the
ctf_slice_t is best avoided: because it leads to the whole file after
that point no longer being naturally aligned, all multibyte accesses
from then on must use memmove() to avoid unaligned access on platforms
where that is fatal. In future, this is planned, but for now we are
still doing direct access in many places, so we must revert to making
ctf_slice_t properly aligned for storage in an array.
Rather than wasting bytes on padding, we boost the size of cts_offset
and cts_bits. This is still a waste of space (we cannot have offsets or
bits in bitfields > 256) but it cannot be avoided for now, and slices
are not so common that this will be a serious problem.
A possibly-worse endianness problem fixed at the same time involves
a codepath used only for foreign-endian, uncompressed CTF files, where
we were not copying the actual CTF data into the buffer, leading to
libctf reading only zeroes (or, possibly, uninitialized garbage).
Finally, when we read in a CTF file, we copy the header and work from
the copy. We were flipping the endianness of the header copy, and of
the body of the file buffer, but not of the header in the file buffer
itself: so if we write the file back out again we end up with an
unreadable frankenfile with header and body of different endiannesses.
Fix by flipping both copies of the header.
include/
* ctf.h (ctf_slice_t): Make cts_offset and cts_bits unsigned
short, so following structures are properly aligned.
libctf/
* ctf-open.c (get_vbytes_common): Return the new slice size.
(ctf_bufopen): Flip the endianness of the CTF-section header copy.
Remember to copy in the CTF data when opening an uncompressed
foreign-endian CTF file. Prune useless variable manipulation.
2019-06-19 19:34:56 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (get_vbytes_common): Return the new slice size.
|
|
|
|
|
|
(ctf_bufopen): Flip the endianness of the CTF-section header copy.
|
|
|
|
|
|
Remember to copy in the CTF data when opening an uncompressed
|
|
|
|
|
|
foreign-endian CTF file. Prune useless variable manipulation.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-19 19:27:18 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_types): Fail when unidentified type kinds are
|
|
|
|
|
|
seen.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-19 19:23:38 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-open.c (ctf_bufopen): Dump header offsets into the debugging
|
|
|
|
|
|
output.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
libctf: drop mmap()-based CTF data allocator
This allocator has the ostensible benefit that it lets us mprotect() the
memory used for CTF storage: but in exchange for this it adds
considerable complexity, since we have to track allocation sizes
ourselves for use at freeing time, note whether the data we are storing
was ctf_data_alloc()ed or not so we know if we can safely mprotect()
it... and while the mprotect()ing has found few bugs, it *has* been the
cause of more than one due to errors in all this tracking leading to us
mprotect()ing bits of the heap and stuff like that.
We are about to start composing CTF buffers from pieces so that we can
do usage-based optimizations on the strtab. This means we need
realloc(), which needs nonportable mremap() and *more* tracking of the
*original* allocation size, and the complexity and bureaucracy of all of
this is just too high for its negligible benefits.
Drop the whole thing and just use malloc() like everyone else. It knows
better than we do when it is safe to use mmap() under the covers,
anyway.
While we're at it, don't leak the entire buffer if ctf_compress_write()
fails to compress it.
libctf/
* ctf-subr.c (_PAGESIZE): Remove.
(ctf_data_alloc): Likewise.
(ctf_data_free): Likewise.
(ctf_data_protect): Likewise.
* ctf-impl.h: Remove declarations.
* ctf-create.c (ctf_update): No longer call ctf_data_protect: use
ctf_free, not ctf_data_free.
(ctf_compress_write): Use ctf_data_alloc, not ctf_alloc. Free
the buffer again on compression error.
* ctf-open.c (ctf_set_base): No longer track the size: call
ctf_free, not ctf_data_free.
(upgrade_types): Likewise. Call ctf_alloc, not ctf_data_alloc.
(ctf_bufopen): Likewise. No longer call ctf_data_protect.
2019-06-19 19:20:47 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-subr.c (_PAGESIZE): Remove.
|
|
|
|
|
|
(ctf_data_alloc): Likewise.
|
|
|
|
|
|
(ctf_data_free): Likewise.
|
|
|
|
|
|
(ctf_data_protect): Likewise.
|
|
|
|
|
|
* ctf-impl.h: Remove declarations.
|
|
|
|
|
|
* ctf-create.c (ctf_update): No longer call ctf_data_protect: use
|
|
|
|
|
|
ctf_free, not ctf_data_free.
|
|
|
|
|
|
(ctf_compress_write): Use ctf_data_alloc, not ctf_alloc. Free
|
|
|
|
|
|
the buffer again on compression error.
|
|
|
|
|
|
* ctf-open.c (ctf_set_base): No longer track the size: call
|
|
|
|
|
|
ctf_free, not ctf_data_free.
|
|
|
|
|
|
(upgrade_types): Likewise. Call ctf_alloc, not ctf_data_alloc.
|
|
|
|
|
|
(ctf_bufopen): Likewise. No longer call ctf_data_protect.
|
|
|
|
|
|
|
2019-07-16 17:42:37 +08:00
|
|
|
|
2019-06-19 Nick Alcock <nick.alcock@oracle.com>
|
2019-06-19 19:14:16 +08:00
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_dtd_insert): Pass on error returns from
|
|
|
|
|
|
ctf_dynhash_insert.
|
|
|
|
|
|
(ctf_dvd_insert): Likewise.
|
|
|
|
|
|
(ctf_add_generic): Likewise.
|
|
|
|
|
|
(ctf_add_variable): Likewise.
|
|
|
|
|
|
* ctf-impl.h: Adjust declarations.
|
|
|
|
|
|
|
2019-06-14 09:00:35 +08:00
|
|
|
|
2019-06-14 Alan Modra <amodra@gmail.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure: Regenerate.
|
|
|
|
|
|
|
2019-06-06 21:10:08 +08:00
|
|
|
|
2019-06-06 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-decls.h: Include <libiberty.h>.
|
|
|
|
|
|
* ctf-lookup.c (ctf_lookup_by_name): Call xstrndup(), not strndup().
|
|
|
|
|
|
|
2019-06-06 20:59:56 +08:00
|
|
|
|
2019-06-06 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_format_type): Cast size_t's used in printf()s.
|
|
|
|
|
|
(ctf_dump_objts): Likewise.
|
|
|
|
|
|
(ctf_dump_funcs): Likewise.
|
|
|
|
|
|
(ctf_dump_member): Likewise.
|
|
|
|
|
|
(ctf_dump_str): Likewise.
|
|
|
|
|
|
|
2019-06-06 20:59:28 +08:00
|
|
|
|
2019-06-06 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (arc_mmap_header): Mark fd as potentially unused.
|
|
|
|
|
|
* ctf-subr.c (ctf_data_protect): Mark both args as potentially unused.
|
|
|
|
|
|
|
2019-06-05 20:34:36 +08:00
|
|
|
|
2019-06-05 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_write): Eschew %zi format specifier.
|
|
|
|
|
|
(ctf_arc_open_by_offset): Likewise.
|
|
|
|
|
|
* ctf-create.c (ctf_add_type): Likewise.
|
|
|
|
|
|
|
Use CHAR_BIT instead of NBBY in libctf
On x86-64 Fedora 29, I tried to build a mingw-hosted gdb that targets
ppc-linux. You can do this with:
../binutils-gdb/configure --host=i686-w64-mingw32 --target=ppc-linux \
--disable-{binutils,gas,gold,gprof,ld}
The build failed with these errors in libctf:
In file included from ../../binutils-gdb/libctf/ctf-create.c:20:
../../binutils-gdb/libctf/ctf-create.c: In function 'ctf_add_encoded':
../../binutils-gdb/libctf/ctf-create.c:803:59: error: 'NBBY' undeclared (first use in this function)
dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, NBBY) / NBBY);
^~~~
../../binutils-gdb/libctf/ctf-impl.h:254:42: note: in definition of macro 'P2ROUNDUP'
#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
^~~~~
../../binutils-gdb/libctf/ctf-create.c:803:59: note: each undeclared identifier is reported only once for each function it appears in
dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, NBBY) / NBBY);
^~~~
../../binutils-gdb/libctf/ctf-impl.h:254:42: note: in definition of macro 'P2ROUNDUP'
#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
^~~~~
../../binutils-gdb/libctf/ctf-create.c: In function 'ctf_add_slice':
../../binutils-gdb/libctf/ctf-create.c:862:59: error: 'NBBY' undeclared (first use in this function)
dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, NBBY) / NBBY);
^~~~
../../binutils-gdb/libctf/ctf-impl.h:254:42: note: in definition of macro 'P2ROUNDUP'
#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
^~~~~
../../binutils-gdb/libctf/ctf-create.c: In function 'ctf_add_member_offset':
../../binutils-gdb/libctf/ctf-create.c:1341:21: error: 'NBBY' undeclared (first use in this function)
off += lsize * NBBY;
^~~~
../../binutils-gdb/libctf/ctf-create.c: In function 'ctf_add_type':
../../binutils-gdb/libctf/ctf-create.c:1822:16: warning: unknown conversion type character 'z' in format [-Wformat=]
ctf_dprintf ("Conflict for type %s against ID %lx: "
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../binutils-gdb/libctf/ctf-create.c:1823:35: note: format string is defined here
"union size differs, old %zi, new %zi\n",
^
../../binutils-gdb/libctf/ctf-create.c:1822:16: warning: unknown conversion type character 'z' in format [-Wformat=]
ctf_dprintf ("Conflict for type %s against ID %lx: "
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../binutils-gdb/libctf/ctf-create.c:1823:44: note: format string is defined here
"union size differs, old %zi, new %zi\n",
^
../../binutils-gdb/libctf/ctf-create.c:1822:16: warning: too many arguments for format [-Wformat-extra-args]
ctf_dprintf ("Conflict for type %s against ID %lx: "
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This patch fixes the actual errors in here. I did not try to fix the
printf warnings, though I think someone ought to.
Ok?
libctf/ChangeLog
2019-06-04 Tom Tromey <tromey@adacore.com>
* ctf-create.c (ctf_add_encoded, ctf_add_slice)
(ctf_add_member_offset): Use CHAR_BIT, not NBBY.
2019-06-05 02:16:57 +08:00
|
|
|
|
2019-06-04 Tom Tromey <tromey@adacore.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (ctf_add_encoded, ctf_add_slice)
|
|
|
|
|
|
(ctf_add_member_offset): Use CHAR_BIT, not NBBY.
|
|
|
|
|
|
|
2019-06-04 22:04:49 +08:00
|
|
|
|
2019-06-04 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.ac: Check for O_CLOEXEC.
|
|
|
|
|
|
* ctf-decls.h (O_CLOEXEC): Define (to 0), if need be.
|
|
|
|
|
|
* config.h.in: Regenerate.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
2019-06-03 21:02:09 +08:00
|
|
|
|
2019-06-04 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* qsort_r.c: Rename to...
|
|
|
|
|
|
* ctf-qsort_r.c: ... this.
|
|
|
|
|
|
(_quicksort): Define to ctf_qsort_r.
|
|
|
|
|
|
* ctf-decls.h (qsort_r): Remove.
|
|
|
|
|
|
(ctf_qsort_r): Add.
|
|
|
|
|
|
(struct ctf_qsort_arg): New, transport the real ARG and COMPAR.
|
|
|
|
|
|
(ctf_qsort_compar_thunk): Rearrange the arguments to COMPAR.
|
|
|
|
|
|
* Makefile.am (libctf_a_LIBADD): Remove.
|
|
|
|
|
|
(libctf_a_SOURCES): New, add ctf-qsort_r.c.
|
|
|
|
|
|
* ctf-archive.c (ctf_arc_write): Call ctf_qsort_r, not qsort_r.
|
|
|
|
|
|
* ctf-create.c (ctf_update): Likewise.
|
|
|
|
|
|
* configure.ac: Check for BSD versus GNU qsort_r signature.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
* config.h.in: Likewise.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
2019-06-04 03:26:02 +08:00
|
|
|
|
2019-06-03 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c (ctf_dump_funcs): Free in the right place.
|
|
|
|
|
|
|
libctf: fix a number of build problems found on Solaris and NetBSD
- Use of nonportable <endian.h>
- Use of qsort_r
- Use of zlib without appropriate magic to pull in the binutils zlib
- Use of off64_t without checking (fixed by dropping the unused fields
that need off64_t entirely)
- signedness problems due to long being too short a type on 32-bit
platforms: ctf_id_t is now 'unsigned long', and CTF_ERR must be
used only for functions that return ctf_id_t
- One lingering use of bzero() and of <sys/errno.h>
All fixed, using code from gnulib where possible.
Relatedly, set cts_size in a couple of places it was missed
(string table and symbol table loading upon ctf_bfdopen()).
binutils/
* objdump.c (make_ctfsect): Drop cts_type, cts_flags, and
cts_offset.
* readelf.c (shdr_to_ctf_sect): Likewise.
include/
* ctf-api.h (ctf_sect_t): Drop cts_type, cts_flags, and cts_offset.
(ctf_id_t): This is now an unsigned type.
(CTF_ERR): Cast it to ctf_id_t. Note that it should only be used
for ctf_id_t-returning functions.
libctf/
* Makefile.am (ZLIB): New.
(ZLIBINC): Likewise.
(AM_CFLAGS): Use them.
(libctf_a_LIBADD): New, for LIBOBJS.
* configure.ac: Check for zlib, endian.h, and qsort_r.
* ctf-endian.h: New, providing htole64 and le64toh.
* swap.h: Code style fixes.
(bswap_identity_64): New.
* qsort_r.c: New, from gnulib (with one added #include).
* ctf-decls.h: New, providing a conditional qsort_r declaration,
and unconditional definitions of MIN and MAX.
* ctf-impl.h: Use it. Do not use <sys/errno.h>.
(ctf_set_errno): Now returns unsigned long.
* ctf-util.c (ctf_set_errno): Adjust here too.
* ctf-archive.c: Use ctf-endian.h.
(ctf_arc_open_by_offset): Use memset, not bzero. Drop cts_type,
cts_flags and cts_offset.
(ctf_arc_write): Drop debugging dependent on the size of off_t.
* ctf-create.c: Provide a definition of roundup if not defined.
(ctf_create): Drop cts_type, cts_flags and cts_offset.
(ctf_add_reftype): Do not check if type IDs are below zero.
(ctf_add_slice): Likewise.
(ctf_add_typedef): Likewise.
(ctf_add_member_offset): Cast error-returning ssize_t's to size_t
when known error-free. Drop CTF_ERR usage for functions returning
int.
(ctf_add_member_encoded): Drop CTF_ERR usage for functions returning
int.
(ctf_add_variable): Likewise.
(enumcmp): Likewise.
(enumadd): Likewise.
(membcmp): Likewise.
(ctf_add_type): Likewise. Cast error-returning ssize_t's to size_t
when known error-free.
* ctf-dump.c (ctf_is_slice): Drop CTF_ERR usage for functions
returning int: use CTF_ERR for functions returning ctf_type_id.
(ctf_dump_label): Likewise.
(ctf_dump_objts): Likewise.
* ctf-labels.c (ctf_label_topmost): Likewise.
(ctf_label_iter): Likewise.
(ctf_label_info): Likewise.
* ctf-lookup.c (ctf_func_args): Likewise.
* ctf-open.c (upgrade_types): Cast to size_t where appropriate.
(ctf_bufopen): Likewise. Use zlib types as needed.
* ctf-types.c (ctf_member_iter): Drop CTF_ERR usage for functions
returning int.
(ctf_enum_iter): Likewise.
(ctf_type_size): Likewise.
(ctf_type_align): Likewise. Cast to size_t where appropriate.
(ctf_type_kind_unsliced): Likewise.
(ctf_type_kind): Likewise.
(ctf_type_encoding): Likewise.
(ctf_member_info): Likewise.
(ctf_array_info): Likewise.
(ctf_enum_value): Likewise.
(ctf_type_rvisit): Likewise.
* ctf-open-bfd.c (ctf_bfdopen): Drop cts_type, cts_flags and
cts_offset.
(ctf_simple_open): Likewise.
(ctf_bfdopen_ctfsect): Likewise. Set cts_size properly.
* Makefile.in: Regenerate.
* aclocal.m4: Likewise.
* config.h: Likewise.
* configure: Likewise.
2019-05-31 17:10:51 +08:00
|
|
|
|
2019-05-29 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* Makefile.am (ZLIB): New.
|
|
|
|
|
|
(ZLIBINC): Likewise.
|
|
|
|
|
|
(AM_CFLAGS): Use them.
|
|
|
|
|
|
(libctf_a_LIBADD): New, for LIBOBJS.
|
|
|
|
|
|
* configure.ac: Check for zlib, endian.h, and qsort_r.
|
|
|
|
|
|
* ctf-endian.h: New, providing htole64 and le64toh.
|
|
|
|
|
|
* swap.h: Code style fixes.
|
|
|
|
|
|
(bswap_identity_64): New.
|
|
|
|
|
|
* qsort_r.c: New, from gnulib (with one added #include).
|
|
|
|
|
|
* ctf-decls.h: New, providing a conditional qsort_r declaration,
|
|
|
|
|
|
and unconditional definitions of MIN and MAX.
|
|
|
|
|
|
* ctf-impl.h: Use it. Do not use <sys/errno.h>.
|
|
|
|
|
|
(ctf_set_errno): Now returns unsigned long.
|
|
|
|
|
|
* ctf-util.c (ctf_set_errno): Adjust here too.
|
|
|
|
|
|
* ctf-archive.c: Use ctf-endian.h.
|
|
|
|
|
|
(ctf_arc_open_by_offset): Use memset, not bzero. Drop cts_type,
|
|
|
|
|
|
cts_flags and cts_offset.
|
|
|
|
|
|
(ctf_arc_write): Drop debugging dependent on the size of off_t.
|
|
|
|
|
|
* ctf-create.c: Provide a definition of roundup if not defined.
|
|
|
|
|
|
(ctf_create): Drop cts_type, cts_flags and cts_offset.
|
|
|
|
|
|
(ctf_add_reftype): Do not check if type IDs are below zero.
|
|
|
|
|
|
(ctf_add_slice): Likewise.
|
|
|
|
|
|
(ctf_add_typedef): Likewise.
|
|
|
|
|
|
(ctf_add_member_offset): Cast error-returning ssize_t's to size_t
|
|
|
|
|
|
when known error-free. Drop CTF_ERR usage for functions returning
|
|
|
|
|
|
int.
|
|
|
|
|
|
(ctf_add_member_encoded): Drop CTF_ERR usage for functions returning
|
|
|
|
|
|
int.
|
|
|
|
|
|
(ctf_add_variable): Likewise.
|
|
|
|
|
|
(enumcmp): Likewise.
|
|
|
|
|
|
(enumadd): Likewise.
|
|
|
|
|
|
(membcmp): Likewise.
|
|
|
|
|
|
(ctf_add_type): Likewise. Cast error-returning ssize_t's to size_t
|
|
|
|
|
|
when known error-free.
|
|
|
|
|
|
* ctf-dump.c (ctf_is_slice): Drop CTF_ERR usage for functions
|
|
|
|
|
|
returning int: use CTF_ERR for functions returning ctf_type_id.
|
|
|
|
|
|
(ctf_dump_label): Likewise.
|
|
|
|
|
|
(ctf_dump_objts): Likewise.
|
|
|
|
|
|
* ctf-labels.c (ctf_label_topmost): Likewise.
|
|
|
|
|
|
(ctf_label_iter): Likewise.
|
|
|
|
|
|
(ctf_label_info): Likewise.
|
|
|
|
|
|
* ctf-lookup.c (ctf_func_args): Likewise.
|
|
|
|
|
|
* ctf-open.c (upgrade_types): Cast to size_t where appropriate.
|
|
|
|
|
|
(ctf_bufopen): Likewise. Use zlib types as needed.
|
|
|
|
|
|
* ctf-types.c (ctf_member_iter): Drop CTF_ERR usage for functions
|
|
|
|
|
|
returning int.
|
|
|
|
|
|
(ctf_enum_iter): Likewise.
|
|
|
|
|
|
(ctf_type_size): Likewise.
|
|
|
|
|
|
(ctf_type_align): Likewise. Cast to size_t where appropriate.
|
|
|
|
|
|
(ctf_type_kind_unsliced): Likewise.
|
|
|
|
|
|
(ctf_type_kind): Likewise.
|
|
|
|
|
|
(ctf_type_encoding): Likewise.
|
|
|
|
|
|
(ctf_member_info): Likewise.
|
|
|
|
|
|
(ctf_array_info): Likewise.
|
|
|
|
|
|
(ctf_enum_value): Likewise.
|
|
|
|
|
|
(ctf_type_rvisit): Likewise.
|
|
|
|
|
|
* ctf-open-bfd.c (ctf_bfdopen): Drop cts_type, cts_flags and
|
|
|
|
|
|
cts_offset.
|
|
|
|
|
|
(ctf_simple_open): Likewise.
|
|
|
|
|
|
(ctf_bfdopen_ctfsect): Likewise. Set cts_size properly.
|
|
|
|
|
|
* Makefile.in: Regenerate.
|
|
|
|
|
|
* aclocal.m4: Likewise.
|
|
|
|
|
|
* config.h: Likewise.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
2019-05-29 17:11:37 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* configure.in: Check for bfd_section_from_elf_index.
|
|
|
|
|
|
* configure: Regenerate.
|
|
|
|
|
|
* config.h.in [HAVE_BFD_ELF]: Likewise.
|
|
|
|
|
|
* libctf/ctf_open_bfd (ctf_bfdopen_ctfsect): Use it.
|
|
|
|
|
|
abfd is potentially unused now.
|
|
|
|
|
|
|
2019-04-24 18:49:48 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* Makefile.am: New.
|
|
|
|
|
|
* Makefile.in: Regenerated.
|
|
|
|
|
|
* config.h.in: Likewise.
|
|
|
|
|
|
* aclocal.m4: Likewise.
|
|
|
|
|
|
* configure: Likewise.
|
|
|
|
|
|
|
2019-04-24 18:41:00 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-dump.c: New.
|
|
|
|
|
|
|
2019-04-24 18:35:37 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-labels.c: New.
|
|
|
|
|
|
|
2019-04-24 18:26:42 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h (_libctf_version): New declaration.
|
|
|
|
|
|
* ctf-subr.c (_libctf_version): Define it.
|
|
|
|
|
|
(ctf_version): New.
|
|
|
|
|
|
|
2019-04-24 18:22:03 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c (enumcmp): New.
|
|
|
|
|
|
(enumadd): Likewise.
|
|
|
|
|
|
(membcmp): Likewise.
|
|
|
|
|
|
(membadd): Likewise.
|
|
|
|
|
|
(ctf_add_type): Likewise.
|
|
|
|
|
|
|
2019-04-24 18:15:33 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-lookup.c (isqualifier): New.
|
|
|
|
|
|
(ctf_lookup_by_name): Likewise.
|
|
|
|
|
|
(struct ctf_lookup_var_key): Likewise.
|
|
|
|
|
|
(ctf_lookup_var): Likewise.
|
|
|
|
|
|
(ctf_lookup_variable): Likewise.
|
|
|
|
|
|
(ctf_lookup_symbol_name): Likewise.
|
|
|
|
|
|
(ctf_lookup_by_symbol): Likewise.
|
|
|
|
|
|
(ctf_func_info): Likewise.
|
|
|
|
|
|
(ctf_func_args): Likewise.
|
|
|
|
|
|
|
2019-04-24 18:03:37 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-decl.c: New file.
|
|
|
|
|
|
* ctf-types.c: Likewise.
|
|
|
|
|
|
* ctf-impl.h: New declarations.
|
|
|
|
|
|
|
libctf: ELF file opening via BFD
These functions let you open an ELF file with a customarily-named CTF
section in it, automatically opening the CTF file or archive and
associating the symbol and string tables in the ELF file with the CTF
container, so that you can look up the types of symbols in the ELF file
via ctf_lookup_by_symbol(), and so that strings can be shared between
the ELF file and CTF container, to save space.
It uses BFD machinery to do so. This has now been lightly tested and
seems to work. In particular, if you already have a bfd you can pass
it in to ctf_bfdopen(), and if you want a bfd made for you you can
call ctf_open() or ctf_fdopen(), optionally specifying a target (or
try once without a target and then again with one if you get
ECTF_BFD_AMBIGUOUS back).
We use a forward declaration for the struct bfd in ctf-api.h, so that
ctf-api.h users are not required to pull in <bfd.h>. (This is mostly
for the sake of readelf.)
libctf/
* ctf-open-bfd.c: New file.
* ctf-open.c (ctf_close): New.
* ctf-impl.h: Include bfd.h.
(ctf_file): New members ctf_data_mmapped, ctf_data_mmapped_len.
(ctf_archive_internal): New members ctfi_abfd, ctfi_data,
ctfi_bfd_close.
(ctf_bfdopen_ctfsect): New declaration.
(_CTF_SECTION): likewise.
include/
* ctf-api.h (struct bfd): New forward.
(ctf_fdopen): New.
(ctf_bfdopen): Likewise.
(ctf_open): Likewise.
(ctf_arc_open): Likewise.
2019-04-24 17:46:39 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open-bfd.c: New file.
|
|
|
|
|
|
* ctf-open.c (ctf_close): New.
|
|
|
|
|
|
* ctf-impl.h: Include bfd.h.
|
|
|
|
|
|
(ctf_file): New members ctf_data_mmapped, ctf_data_mmapped_len.
|
|
|
|
|
|
(ctf_archive_internal): New members ctfi_abfd, ctfi_data,
|
|
|
|
|
|
ctfi_bfd_close.
|
|
|
|
|
|
(ctf_bfdopen_ctfsect): New declaration.
|
|
|
|
|
|
(_CTF_SECTION): likewise.
|
|
|
|
|
|
|
libctf: mmappable archives
If you need to store a large number of CTF containers somewhere, this
provides a dedicated facility for doing so: an mmappable archive format
like a very simple tar or ar without all the system-dependent format
horrors or need for heavy file copying, with built-in compression of
files above a particular size threshold.
libctf automatically mmap()s uncompressed elements of these archives, or
uncompresses them, as needed. (If the platform does not support mmap(),
copying into dynamically-allocated buffers is used.)
Archive iteration operations are partitioned into raw and non-raw
forms. Raw operations pass thhe raw archive contents to the callback:
non-raw forms open each member with ctf_bufopen() and pass the resulting
ctf_file_t to the iterator instead. This lets you manipulate the raw
data in the archive, or the contents interpreted as a CTF file, as
needed.
It is not yet known whether we will store CTF archives in a linked ELF
object in one of these (akin to debugdata) or whether they'll get one
section per TU plus one parent container for types shared between them.
(In the case of ELF objects with very large numbers of TUs, an archive
of all of them would seem preferable, so we might just use an archive,
and add lzma support so you can assume that .gnu_debugdata and .ctf are
compressed using the same algorithm if both are present.)
To make usage easier, the ctf_archive_t is not the on-disk
representation but an abstraction over both ctf_file_t's and archives of
many ctf_file_t's: users see both CTF archives and raw CTF files as
ctf_archive_t's upon opening, the only difference being that a raw CTF
file has only a single "archive member", named ".ctf" (the default if a
null pointer is passed in as the name). The next commit will make use
of this facility, in addition to providing the public interface to
actually open archives. (In the future, it should be possible to have
all CTF sections in an ELF file appear as an "archive" in the same
fashion.)
This machinery is also used to allow library-internal creators of
ctf_archive_t's (such as the next commit) to stash away an ELF string
and symbol table, so that all opens of members in a given archive will
use them. This lets CTF archives exploit the ELF string and symbol
table just like raw CTF files can.
(All this leads to somewhat confusing type naming. The ctf_archive_t is
a typedef for the opaque internal type, struct ctf_archive_internal: the
non-internal "struct ctf_archive" is the on-disk structure meant for
other libraries manipulating CTF files. It is probably clearest to use
the struct name for struct ctf_archive_internal inside the program, and
the typedef names outside.)
libctf/
* ctf-archive.c: New.
* ctf-impl.h (ctf_archive_internal): New type.
(ctf_arc_open_internal): New declaration.
(ctf_arc_bufopen): Likewise.
(ctf_arc_close_internal): Likewise.
include/
* ctf.h (CTFA_MAGIC): New.
(struct ctf_archive): New.
(struct ctf_archive_modent): Likewise.
* ctf-api.h (ctf_archive_member_f): New.
(ctf_archive_raw_member_f): Likewise.
(ctf_arc_write): Likewise.
(ctf_arc_close): Likewise.
(ctf_arc_open_by_name): Likewise.
(ctf_archive_iter): Likewise.
(ctf_archive_raw_iter): Likewise.
(ctf_get_arc): Likewise.
2019-04-24 18:30:17 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-archive.c: New.
|
|
|
|
|
|
* ctf-impl.h (ctf_archive_internal): New type.
|
|
|
|
|
|
(ctf_arc_open_internal): New declaration.
|
|
|
|
|
|
(ctf_arc_bufopen): Likewise.
|
|
|
|
|
|
(ctf_arc_close_internal): Likewise.
|
|
|
|
|
|
|
libctf: opening
This fills in the other half of the opening/creation puzzle: opening of
already-existing CTF files. Such files are always read-only: if you
want to add to a CTF file opened with one of the opening functions in
this file, use ctf_add_type(), in a later commit, to copy appropriate
types into a newly ctf_create()d, writable container.
The lowest-level opening functions are in here: ctf_bufopen(), which
takes ctf_sect_t structures akin to ELF section headers, and
ctf_simple_open(), which can be used if you don't have an entire ELF
section header to work from. Both will malloc() new space for the
buffers only if necessary, will mmap() directly from the file if
requested, and will mprotect() it afterwards to prevent accidental
corruption of the types. These functions are also used by ctf_update()
when converting types in a writable container into read-only types that
can be looked up using the lookup functions (in later commits).
The files are always of the native endianness of the system that created
them: at read time, the endianness of the header magic number is used to
determine whether or not the file needs byte-swapping, and the entire
thing is aggressively byte-swapped.
The agggressive nature of this swapping avoids complicating the rest of
the code with endianness conversions, while the native endianness
introduces no byte-swapping overhead in the common case. (The
endianness-independence code is also much newer than everything else in
this file, and deserves closer scrutiny.)
The accessors at the top of the file are there to transparently support
older versions of the CTF file format, allowing translation from older
formats that have different sizes for the structures in ctf.h:
currently, these older formats are intermingled with the newer ones in
ctf.h: they will probably migrate to a compatibility header in time, to
ease readability. The ctf_set_base() function is split out for the same
reason: when conversion code to a newer format is written, it would need
to malloc() new storage for the entire ctf_file_t if a file format
change causes it to grow, and for that we need ctf_set_base() to be a
separate function.
One pair of linked data structures supported by this file has no
creation code in libctf yet: the data and function object sections read
by init_symtab(). These will probably arrive soon, when the linker comes
to need them. (init_symtab() has hardly been changed since 2009, but if
any code in libctf has rotted over time, this will.)
A few simple accessors are also present that can even be called on
read-only containers because they don't actually modify them, since the
relevant things are not stored in the container but merely change its
operation: ctf_setmodel(), which lets you specify whether a container is
LP64 or not (used to statically determine the sizes of a few types),
ctf_import(), which is the only way to associate a parent container with
a child container, and ctf_setspecific(), which lets the caller
associate an arbitrary pointer with the CTF container for any use. If
the user doesn't call these functions correctly, libctf will misbehave:
this is particularly important for ctf_import(), since a container built
against a given parent container will not be able to resolve types that
depend on types in the parent unless it is ctf_import()ed with a parent
container with the same set of types at the same IDs, or a superset.
Possible future extensions (also noted in the ctf-hash.c file) include
storing a count of things so that we don't need to do one pass over the
CTF file counting everything, and computing a perfect hash at CTF
creation time in some compact form, storing it in the CTF file, and
using it to hash things so we don't need to do a second pass over the
entire CTF file to set up the hashes used to go from names to type IDs.
(There are multiple such hashes, one for each C type namespace: types,
enums, structs, and unions.)
libctf/
* ctf-open.c: New file.
* swap.h: Likewise.
include/
* ctf-api.h (ctf_file_close): New declaration.
(ctf_getdatasect): Likewise.
(ctf_parent_file): Likewise.
(ctf_parent_name): Likewise.
(ctf_parent_name_set): Likewise.
(ctf_import): Likewise.
(ctf_setmodel): Likewise.
(ctf_getmodel): Likewise.
(ctf_setspecific): Likewise.
(ctf_getspecific): Likewise.
2019-04-24 17:17:13 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-open.c: New file.
|
|
|
|
|
|
* swap.h: Likewise.
|
|
|
|
|
|
|
libctf: creation functions
The CTF creation process looks roughly like (error handling elided):
int err;
ctf_file_t *foo = ctf_create (&err);
ctf_id_t type = ctf_add_THING (foo, ...);
ctf_update (foo);
ctf_*write (...);
Some ctf_add_THING functions accept other type IDs as arguments,
depending on the type: cv-quals, pointers, and structure and union
members all take other types as arguments. So do 'slices', which
let you take an existing integral type and recast it as a type
with a different bitness or offset within a byte, for bitfields.
One class of THING is not a type: "variables", which are mappings
of names (in the internal string table) to types. These are mostly
useful when encoding variables that do not appear in a symbol table
but which some external user has some other way to figure out the
address of at runtime (dynamic symbol lookup or querying a VM
interpreter or something).
You can snapshot the creation process at any point: rolling back to a
snapshot deletes all types and variables added since that point.
You can make arbitrary type queries on the CTF container during the
creation process, but you must call ctf_update() first, which
translates the growing dynamic container into a static one (this uses
the CTF opening machinery, added in a later commit), which is quite
expensive. This function must also be called after adding types
and before writing the container out.
Because addition of types involves looking up existing types, we add a
little of the type lookup machinery here, as well: only enough to
look up types in dynamic containers under construction.
libctf/
* ctf-create.c: New file.
* ctf-lookup.c: New file.
include/
* ctf-api.h (zlib.h): New include.
(ctf_sect_t): New.
(ctf_sect_names_t): Likewise.
(ctf_encoding_t): Likewise.
(ctf_membinfo_t): Likewise.
(ctf_arinfo_t): Likewise.
(ctf_funcinfo_t): Likewise.
(ctf_lblinfo_t): Likewise.
(ctf_snapshot_id_t): Likewise.
(CTF_FUNC_VARARG): Likewise.
(ctf_simple_open): Likewise.
(ctf_bufopen): Likewise.
(ctf_create): Likewise.
(ctf_add_array): Likewise.
(ctf_add_const): Likewise.
(ctf_add_enum_encoded): Likewise.
(ctf_add_enum): Likewise.
(ctf_add_float): Likewise.
(ctf_add_forward): Likewise.
(ctf_add_function): Likewise.
(ctf_add_integer): Likewise.
(ctf_add_slice): Likewise.
(ctf_add_pointer): Likewise.
(ctf_add_type): Likewise.
(ctf_add_typedef): Likewise.
(ctf_add_restrict): Likewise.
(ctf_add_struct): Likewise.
(ctf_add_union): Likewise.
(ctf_add_struct_sized): Likewise.
(ctf_add_union_sized): Likewise.
(ctf_add_volatile): Likewise.
(ctf_add_enumerator): Likewise.
(ctf_add_member): Likewise.
(ctf_add_member_offset): Likewise.
(ctf_add_member_encoded): Likewise.
(ctf_add_variable): Likewise.
(ctf_set_array): Likewise.
(ctf_update): Likewise.
(ctf_snapshot): Likewise.
(ctf_rollback): Likewise.
(ctf_discard): Likewise.
(ctf_write): Likewise.
(ctf_gzwrite): Likewise.
(ctf_compress_write): Likewise.
2019-04-24 05:45:46 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-create.c: New file.
|
|
|
|
|
|
* ctf-lookup.c: New file.
|
|
|
|
|
|
|
2019-04-24 05:24:13 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h: New definitions and declarations for type creation
|
|
|
|
|
|
and lookup.
|
|
|
|
|
|
|
2019-04-24 05:12:16 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-hash.c: New file.
|
|
|
|
|
|
* ctf-impl.h: New declarations.
|
|
|
|
|
|
|
2019-04-24 05:05:52 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-error.c: New file.
|
|
|
|
|
|
|
2019-04-24 04:45:30 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-util.c: New file.
|
|
|
|
|
|
* elf.h: Likewise.
|
|
|
|
|
|
* ctf-impl.h: Include it, and add declarations.
|
|
|
|
|
|
|
2019-04-24 01:55:27 +08:00
|
|
|
|
2019-05-28 Nick Alcock <nick.alcock@oracle.com>
|
|
|
|
|
|
|
|
|
|
|
|
* ctf-impl.h: New file.
|
|
|
|
|
|
* ctf-subr.c: New file.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Local Variables:
|
|
|
|
|
|
mode: change-log
|
|
|
|
|
|
left-margin: 8
|
|
|
|
|
|
fill-column: 76
|
|
|
|
|
|
version-control: never
|
|
|
|
|
|
End:
|
