Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity
Files
b5d3790c6684a85552e0f57372a2b3b7fae0ed96
binutils-gdb/libctf/ctf-impl.h
Nick Alcock b5d3790c66 libctf: consecutive ctf_id_t assignment 
This change modifies type ID assignment in CTF so that it works like BTF:
rather than flipping the high bit on for types in child dicts, types ascend
directly from IDs in the parent to IDs in the child, without interruption
(so type 0x4 in the parent is immediately followed by 0x5 in all children).

Doing this while retaining useful semantics for modification of parents is
challenging.  By definition, child type IDs are not known until the parent
is written out, but we don't want to find ourselves constrained to adding
types to the parent in one go, followed by all child types: that would make
the deduplicator a nightmare and would frankly make the entire ctf_add*()
interface next to useless: all existing clients that add types at all
add types to both parents and children without regard for ordering, and
breaking that would probably necessitate redesigning all of them.

So we have to be a litle cleverer.

We approach this the same way as we approach strings in the recent refs
rework: if a parent has children attached (or has ever had them attached
since it was created or last read in), any new types created in the parent
are assigned provisional IDs starting at the very top of the type space and
working down.  (Their indexes in the internal libctf arrays remain
unchanged, so we don't suddenly need multigigabyte indexes!).  At writeout
(preserialization) time, we traverse the type table (and all other table
containing type IDs) and assign refs to every type ID in exactly the same
way we assign refs to every string offset (just a different set of refs --
we don't want to update type IDs with string offset values!).

For a parent dict with children, these refs are real entities in memory:
pointers to the memory locations where type IDs are stored, tracked in the
DTD of each type.  As we traverse the type table, we assign real IDs to each
type (by simple incrementation), storing those IDs in a new dtd_final_type
field in the DTD for each type.  Once the type table and all other tables
containing type IDs are fully traversed, we update all the refs and
overwrite the IDs currently residing in each with the final IDs for each
type.

That fixes up IDs in the parent dict itself (including forward references in
structs and the like: that's why the ref updates only happen at the end);
but what about child dicts' references, both to parent types and to their
own?  We add armouring to enforce that parent dicts are always serialized
before their children (which ctf-link.c already does, because it's a
precondition for strtab deduplication), and then arrange that when a ref is
added to a type whose ID has been assigned (has a dtd_final_type), we just
immediately do an update rather than storing a ref for later updating.
Since the parent is already serialized, all parent type IDs have a
dtd_final_type by this point, and all parent IDs in the children are
properly updated. The child types can now be renumbered now we now the
number of types in the parent, and their refs updated identically to what
was just done with the parent.

One wrinkle: before the child refs are updated, while we are working over
the child's type section, the type IDs in the child start from 1 (or
something like that), which might seem to overlap the parent IDs.  But this
is not the case: when you serialize the parent, the IDs written out to disk
are changed, but the only change to the representation in memory is that we
remember a dtd_final_type for each type (and use it to update all the child
type refs): its ID in memory is the same as it always was, a nonoverlapping
provisional ID higher than any other valid ID.  We enforce all of this by
asserting that when you add a ref to a type, the memory location that is
modified must be in the buffer being serialized: the code will not let you
accidentally modify the actual DTDs in memory.

We track the number of types in the parent in a new CTFv4 (not BTF) header
field (the dumper is updated): we will also use this to open CTFv3 child
dicts without change by simply declaring for them that the parent dict has
2^31 types in it (or 2^15, for v2 and below): the IDs in the children then
naturally come out right with no other changes needed.  (Right now, opening
CTFv3 child dicts requires extra compatibility code that has not been
written, but that code will no longer need to worry about type ID
differences.)

Various things are newly forbidden:

 - you cannot ctf_import() a child into a parent if you already ctf_add()ed
   types to the child, because all its IDs would change (and since you
   already cannot ctf_add() types to a child that hasn't had its parent
   imported, this in practice means only that ctf_create() must be followed
   immediately by a ctf_import() if this is a new child, which all sane
   clients were doing anyway).

 - You cannot import a child into a parent which has the wrong number of
   (non-provisional) types, again because all its IDs would be wrong:
   because parents only add types in the provisional space if children are
   attached to it, this would break the not unknown case of opening an
   archive, adding types to the parent, and only then importing children
   into it, so we add a special case: archive members which are not children
   in an archive with more than one member always pretend to have at least
   one child, so type additions in them are always provisional even before
   you ctf_import anything. In practice, this does exactly what we want,
   since all archives so far are created by the linker and have one parent
   and N children of that parent.

Because this introduces huge gaps between index and type ID for provisional
types, some extra assertions are added to ensure that the internal
ctf_type_to_index() is only ever called on types in the current dict (never
a parent dict): before now, this was just taken on trust, and it was often
wrong (which at best led to wrong results, as wrong array indexes were used,
and at worst to a buffer overflow). When hash debugging is on (suggesting
that the user doesn't mind expensive checks), every ctf_type_to_index()
triggers a ctf_index_to_type() to make sure that the operations are proper
inverses.

Lots and lots of tests are added to verify that assignment works and that
updating of every type kind works fine -- existing tests suffice for
type IDs in the variable and symtypetab sections.

The ld-ctf tests get a bunch of largely display-based updates: various
tests refer to 0x8... type IDs, which no longer exist, and because the
IDs are shorter all the spacing and alignment has changed.
2025-03-16 15:25:27 +00:00

825 lines
35 KiB
C
Raw Blame History

/* Implementation header.
Copyright (C) 2019-2025 Free Software Foundation, Inc.
This file is part of libctf.
libctf is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not see
<http://www.gnu.org/licenses/>. */
#ifndef _CTF_IMPL_H
#define _CTF_IMPL_H
#include "config.h"
#include <errno.h>
#include <sys/param.h>
#include "ctf-decls.h"
#include <ctf-api.h>
#include "ctf-sha1.h"
#include <sys/types.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <elf.h>
#include <bfd.h>
#include "hashtab.h"
#include "ctf-intl.h"
#ifdef __cplusplus
extern "C"
{
#endif
/* Tuning. */
/* The proportion of symtypetab entries which must be pads before we consider it
worthwhile to emit a symtypetab section as an index. Indexes cost time to
look up, but save space all told. Do not set to 1, since this will cause
indexes to be eschewed completely, even in child dicts, at considerable space
cost. */
#define CTF_INDEX_PAD_THRESHOLD .75
/* Compiler attributes. */
#if defined (__GNUC__)
/* GCC. We assume that all compilers claiming to be GCC support sufficiently
many GCC attributes that the code below works. If some non-GCC compilers
masquerading as GCC in fact do not implement these attributes, version checks
may be required. */
/* We use the _libctf_*_ pattern to avoid clashes with any future attribute
macros glibc may introduce, which have names of the pattern
__attribute_blah__. */
#define _libctf_printflike_(string_index,first_to_check) \
__attribute__ ((__format__ (__printf__, (string_index), (first_to_check))))
#define _libctf_unlikely_(x) __builtin_expect ((x), 0)
#define _libctf_unused_ __attribute__ ((__unused__))
#define _libctf_malloc_ __attribute__((__malloc__))
#define _libctf_nonnull_(params) __attribute__((__nonnull__ params))
#else
#define _libctf_printflike_(string_index,first_to_check)
#define _libctf_unlikely_(x) (x)
#define _libctf_unused_
#define _libctf_malloc_
#define _libctf_nonnull_(params)
#define __extension__
#endif
#if defined (ENABLE_LIBCTF_HASH_DEBUGGING) && !defined (NDEBUG)
#include <assert.h>
#define ctf_assert(fp, expr) (assert (expr), 1)
#else
#define ctf_assert(fp, expr) \
_libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__, \
#expr, !!(expr)))
#endif
/* libctf in-memory state. */
typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c. */
typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c. */
typedef struct ctf_dynset ctf_dynset_t; /* Private to ctf-hash.c. */
typedef struct ctf_strs
{
const char *cts_strs; /* Base address of string table. */
size_t cts_len; /* Size of string table in bytes. */
} ctf_strs_t;
typedef struct ctf_strs_writable
{
char *cts_strs; /* Base address of string table. */
size_t cts_len; /* Size of string table in bytes. */
} ctf_strs_writable_t;
typedef struct ctf_dmodel
{
const char *ctd_name; /* Data model name. */
int ctd_code; /* Data model code. */
size_t ctd_pointer; /* Size of void * in bytes. */
size_t ctd_char; /* Size of char in bytes. */
size_t ctd_short; /* Size of short in bytes. */
size_t ctd_int; /* Size of int in bytes. */
size_t ctd_long; /* Size of long in bytes. */
} ctf_dmodel_t;
typedef struct ctf_lookup
{
const char *ctl_prefix; /* String prefix for this lookup. */
size_t ctl_len; /* Length of prefix string in bytes. */
ctf_dynhash_t *ctl_hash; /* Pointer to hash table for lookup. */
} ctf_lookup_t;
typedef struct ctf_dictops
{
uint32_t (*ctfo_get_kind) (uint32_t);
uint32_t (*ctfo_get_root) (uint32_t);
uint32_t (*ctfo_get_vlen) (uint32_t);
ssize_t (*ctfo_get_ctt_size) (const ctf_dict_t *, const ctf_type_t *,
ssize_t *, ssize_t *);
ssize_t (*ctfo_get_vbytes) (ctf_dict_t *, unsigned short, ssize_t, size_t);
} ctf_dictops_t;
typedef struct ctf_list
{
struct ctf_list *l_prev; /* Previous pointer or tail pointer. */
struct ctf_list *l_next; /* Next pointer or head pointer. */
} ctf_list_t;
typedef enum
{
CTF_PREC_BASE,
CTF_PREC_POINTER,
CTF_PREC_ARRAY,
CTF_PREC_FUNCTION,
CTF_PREC_MAX
} ctf_decl_prec_t;
typedef struct ctf_decl_node
{
ctf_list_t cd_list; /* Linked list pointers. */
ctf_id_t cd_type; /* Type identifier. */
uint32_t cd_kind; /* Type kind. */
uint32_t cd_n; /* Type dimension if array. */
} ctf_decl_node_t;
typedef struct ctf_decl
{
ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks. */
int cd_order[CTF_PREC_MAX]; /* Storage order of decls. */
ctf_decl_prec_t cd_qualp; /* Qualifier precision. */
ctf_decl_prec_t cd_ordp; /* Ordered precision. */
char *cd_buf; /* Buffer for output. */
int cd_err; /* Saved error value. */
int cd_enomem; /* Nonzero if OOM during printing. */
} ctf_decl_t;
typedef struct ctf_dtdef
{
ctf_list_t dtd_list; /* List forward/back pointers. */
ctf_id_t dtd_type; /* Type identifier for this definition. */
ctf_id_t dtd_final_type; /* Final (nonprovisional) id, if nonzero. */
ctf_list_t dtd_refs; /* Refs to this DTD's dtd_type: see below. */
ctf_type_t dtd_data; /* Type node, including name. */
size_t dtd_vlen_alloc; /* Total vlen space allocated (vbytes). */
unsigned char *dtd_vlen; /* Variable-length data for this type. */
} ctf_dtdef_t;
typedef struct ctf_dvdef
{
ctf_list_t dvd_list; /* List forward/back pointers. */
char *dvd_name; /* Name associated with variable. */
ctf_id_t dvd_type; /* Type of variable. */
unsigned long dvd_snapshots; /* Snapshot count when inserted. */
} ctf_dvdef_t;
typedef struct ctf_err_warning
{
ctf_list_t cew_list; /* List forward/back pointers. */
int cew_is_warning; /* 1 if warning, 0 if error. */
char *cew_text; /* Error/warning text. */
} ctf_err_warning_t;
/* Atoms associate strings with a list of the CTF items that reference that
string, so that ctf_serialize() can instantiate all the strings using the
ctf_str_atoms and then reassociate them with the real string later.
The csa_offset is the offset within *this particular strtab*: no matter
how many strings the parent has, the childrens' csa_offsets are unchanged.
So csa_offset may not be the value actually returned as the offset of this
string.
Strings can be interned into ctf_str_atom without having refs associated
with them, for values that are returned to callers, etc. Items are only
removed from this table on ctf_close(), but on every ctf_serialize(), all
the csa_refs in all entries are purged. Refs may also be removed if they are
migrated from one atoms table to another as a consequence of strtab
deduplication. */
#define CTF_STR_ATOM_FREEABLE 0x1
#define CTF_STR_ATOM_IN_PARENT 0x2
#define CTF_STR_ATOM_NO_DEDUP 0x4
typedef struct ctf_str_atom
{
char *csa_str; /* Pointer to string (also used as hash key). */
ctf_list_t csa_refs; /* This string's refs. */
uint32_t csa_offset; /* Offset in this strtab, if any. */
uint32_t csa_external_offset; /* External strtab offset, if any. */
unsigned long csa_snapshot_id; /* Snapshot ID at time of creation. */
int csa_flags; /* CTF_STR_ATOM_* flags. */
} ctf_str_atom_t;
/* A single linker-provided symbol, during symbol addition, possibly before we
have been given external strtab refs. */
typedef struct ctf_in_flight_dynsym
{
ctf_list_t cid_list; /* List forward/back pointers. */
ctf_link_sym_t cid_sym; /* The linker-known symbol. */
} ctf_in_flight_dynsym_t;
/* The structure used as the key in a ctf_link_type_mapping. The value is a
type index, not a type ID. */
typedef struct ctf_link_type_key
{
ctf_dict_t *cltk_fp;
ctf_id_t cltk_idx;
} ctf_link_type_key_t;
/* The structure used as the key in a cd_id_to_dict_t on 32-bit platforms. */
typedef struct ctf_type_id_key
{
int ctii_input_num;
ctf_id_t ctii_type;
} ctf_type_id_key_t;
/* Deduplicator state.
The dedup state below uses three terms consistently. A "hash" is a
ctf_dynhash_t; a "hash value" is the hash value of a type as returned by
ctf_dedup_hash_type; a "global type ID" or "global ID" is a packed-together
reference to a single ctf_dict_t (by array index in an array of inputs) and
ctf_id_t, i.e. a single instance of some hash value in some input.
The deduplication algorithm takes a bunch of inputs and yields a single
shared "output" and possibly many outputs corresponding to individual inputs
that still contain types after sharing of unconflicted types. Almost all
deduplicator state is stored in the struct ctf_dedup in the output, though a
(very) few things are stored in inputs for simplicity's sake, usually if they
are linking together things within the scope of a single TU.
Flushed at the end of every ctf_dedup run. */
typedef struct ctf_dedup
{
/* The CTF linker flags in force for this dedup run. */
int cd_link_flags;
/* On 32-bit platforms only, a hash of global type IDs, in the form of
a ctf_link_type_id_key_t. */
ctf_dynhash_t *cd_id_to_dict_t;
/* Atoms tables of decorated names: maps undecorated name to decorated name.
(The actual allocations are in the CTF dict for the former and the real
atoms table for the latter). Uses the same namespaces as ctf_lookups,
below, but has no need for null-termination. */
ctf_dynhash_t *cd_decorated_names[4];
/* Map type names to a hash from type hash value -> number of times each value
has appeared. Enumeration constants are tracked via the enum they appear
in. */
ctf_dynhash_t *cd_name_counts;
/* Map global type IDs to type hash values. Used to determine if types are
already hashed without having to recompute their hash values again, and to
link types together at later stages. Forwards that are peeked through to
structs and unions are not represented in here, so lookups that might be
such a type (in practice, all lookups) must go via cd_replaced_types first
to take this into account. Discarded before each rehashing. */
ctf_dynhash_t *cd_type_hashes;
/* Maps from the names of structs/unions/enums to a a single GID which is the
only appearance of that type in any input: if it appears in more than one
input, a value which is a GID with an input_num of -1 appears. Used in
share-duplicated link mode link modes to determine whether structs/unions
can be cited from multiple TUs. Only populated in that link mode. */
ctf_dynhash_t *cd_struct_origin;
/* Maps type hash values to a set of hash values of the types that cite them:
i.e., pointing backwards up the type graph. Used for recursive conflict
marking. Citations from tagged structures, unions, and forwards do not
appear in this graph. */
ctf_dynhash_t *cd_citers;
/* Maps type hash values to input global type IDs. The value is a set (a
hash) of global type IDs. Discarded before each rehashing. The result of
the ctf_dedup function. */
ctf_dynhash_t *cd_output_mapping;
/* A map giving the GID of the first appearance of each type for each type
hash value. */
ctf_dynhash_t *cd_output_first_gid;
/* Used to ensure that we never try to map a single type ID to more than one
hash. */
ctf_dynhash_t *cd_output_mapping_guard;
/* Maps the global type IDs of structures in input TUs whose members still
need emission to the global type ID of the already-emitted target type
(which has no members yet) in the appropriate target. Uniquely, the latter
ID represents a *target* ID (i.e. the cd_output_mapping of some specified
input): we encode the shared (parent) dict with an ID of -1. */
ctf_dynhash_t *cd_emission_struct_members;
/* A set (a hash) of hash values of conflicting types. */
ctf_dynset_t *cd_conflicting_types;
/* A hash mapping fp *'s of inputs to their input_nums. Used only by
functions outside the core ctf_dedup / ctf_dedup_emit machinery which do
not take an inputs array. */
ctf_dynhash_t *cd_input_nums;
/* Maps type hashes to ctf_id_t's in this dictionary. Populated only at
emission time, in the dictionary where emission is taking place. */
ctf_dynhash_t *cd_output_emission_hashes;
/* Maps the decorated names of conflicted cross-TU forwards that were forcibly
emitted in this TU to their emitted ctf_id_ts. Populated only at emission
time, in the dictionary where emission is taking place. */
ctf_dynhash_t *cd_output_emission_conflicted_forwards;
/* Points to the output counterpart of this input dictionary, at emission
time. */
ctf_dict_t *cd_output;
} ctf_dedup_t;
/* The ctf_dict is the structure used to represent a CTF dictionary to library
clients, who see it only as an opaque pointer. Modifications can therefore
be made freely to this structure without regard to client versioning. The
ctf_dict_t typedef appears in <ctf-api.h> and declares a forward tag.
(A ctf_file_t typedef also appears there, for historical reasons.) */
struct ctf_dict
{
const ctf_dictops_t *ctf_dictops; /* Version-specific dict operations. */
struct ctf_header *ctf_header; /* The header from this CTF dict. */
unsigned char ctf_openflags; /* Flags the dict had when opened. */
ctf_sect_t ctf_data; /* CTF data from object file. */
ctf_sect_t ctf_ext_symtab; /* Symbol table from object file. */
ctf_sect_t ctf_ext_strtab; /* String table from object file. */
int ctf_symsect_little_endian; /* Endianness of the ctf_ext_symtab. */
ctf_dynhash_t *ctf_symhash_func; /* (partial) hash, symsect name -> idx. */
ctf_dynhash_t *ctf_symhash_objt; /* ditto, for object symbols. */
size_t ctf_symhash_latest; /* Amount of symsect scanned so far. */
ctf_dynhash_t *ctf_prov_strtab; /* Maps provisional-strtab offsets
to names. */
ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names. */
void *ctf_data_mmapped; /* CTF data we mmapped, to free later. */
size_t ctf_data_mmapped_len; /* Length of CTF data we mmapped. */
ctf_dynhash_t *ctf_structs; /* Hash table of struct types. */
ctf_dynhash_t *ctf_unions; /* Hash table of union types. */
ctf_dynhash_t *ctf_enums; /* Hash table of enum types. */
ctf_dynhash_t *ctf_names; /* Hash table of remaining types, plus
enumeration constants. */
ctf_lookup_t ctf_lookups[5]; /* Pointers to nametabs for name lookup. */
ctf_strs_t ctf_str[2]; /* Array of string table base and bounds. */
ctf_strs_writable_t *ctf_dynstrtab; /* Dynamically allocated string table, if any. */
ctf_dynhash_t *ctf_str_atoms; /* Hash table of ctf_str_atoms_t. */
uint32_t ctf_str_prov_offset; /* Latest provisional offset assigned so far.
Kept in the parent. Counts down. */
size_t ctf_str_prov_len; /* Length of all unwritten provisional strings. */
unsigned char *ctf_base; /* CTF file pointer. */
unsigned char *ctf_dynbase; /* Freeable CTF file pointer. */
unsigned char *ctf_buf; /* Uncompressed CTF data buffer. */
size_t ctf_size; /* Size of CTF header + uncompressed data. */
unsigned char *ctf_serializing_buf; /* CTF buffer in mid-serialization. */
size_t ctf_serializing_buf_size; /* Length of that buffer. */
ctf_varent_t *ctf_serializing_vars; /* Unsorted vars in mid-serialization. */
size_t ctf_serializing_nvars; /* Number of those vars. */
uint32_t *ctf_sxlate; /* Translation table for unindexed symtypetab
entries. */
unsigned long ctf_nsyms; /* Number of entries in symtab xlate table. */
uint32_t *ctf_txlate; /* Translation table for type IDs. */
uint32_t *ctf_ptrtab; /* Translation table for pointer-to lookups. */
size_t ctf_ptrtab_len; /* Num types storable in ptrtab currently. */
uint32_t *ctf_pptrtab; /* Parent types pointed to by child dicts. */
size_t ctf_pptrtab_len; /* Num types storable in pptrtab currently. */
uint32_t ctf_pptrtab_typemax; /* Max child type when pptrtab last updated. */
ctf_dynset_t *ctf_conflicting_enums; /* Tracks enum constants that conflict. */
uint32_t *ctf_funcidx_names; /* Name of each function symbol in symtypetab
(if indexed). */
uint32_t *ctf_objtidx_names; /* Likewise, for object symbols. */
size_t ctf_nfuncidx; /* Number of funcidx entries. */
uint32_t *ctf_funcidx_sxlate; /* Offsets into funcinfo for a given funcidx. */
uint32_t *ctf_objtidx_sxlate; /* Likewise, for ctf_objtidx. */
size_t ctf_nobjtidx; /* Number of objtidx entries. */
ctf_dynhash_t *ctf_objthash; /* Dynamic: name -> type ID. */
ctf_dynhash_t *ctf_funchash; /* Dynamic: name -> CTF_K_FUNCTION type ID. */
/* The next three are linker-derived state found in ctf_link targets only. */
ctf_dynhash_t *ctf_dynsyms; /* Symbol info from ctf_link_shuffle_syms. */
ctf_link_sym_t **ctf_dynsymidx; /* Indexes ctf_dynsyms by symidx. */
uint32_t ctf_dynsymmax; /* Maximum ctf_dynsym index. */
ctf_list_t ctf_in_flight_dynsyms; /* Dynsyms during accumulation. */
struct ctf_varent *ctf_vars; /* Sorted variable->type mapping. */
unsigned long ctf_nvars; /* Number of variables in ctf_vars. */
uint32_t ctf_typemax; /* Maximum valid type index. */
uint32_t ctf_idmax; /* Maximum valid non-provisional type ID. */
uint32_t ctf_stypes; /* Number of static (non-dynamic) types. */
uint32_t ctf_provtypemax; /* Latest valid provisional type ID.
Counts down. Parent only. */
uint32_t ctf_nprovtypes; /* Number of provisional types (convenience). */
const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above). */
const char *ctf_cuname; /* Compilation unit name (if any). */
char *ctf_dyncuname; /* Dynamically allocated name of CU. */
struct ctf_dict *ctf_parent; /* Parent CTF dict (if any). */
int ctf_parent_unreffed; /* Parent set by ctf_import_unref? */
const char *ctf_parlabel; /* Label in parent dict (if any). */
const char *ctf_parname; /* Basename of parent (if any). */
char *ctf_dynparname; /* Dynamically allocated name of parent. */
uint32_t ctf_refcnt; /* Reference count (for parent links). */
uint32_t ctf_flags; /* Libctf flags (see below). */
uint32_t ctf_max_children; /* Max number of child dicts. */
int ctf_errno; /* Error code for most recent error. */
int ctf_version; /* CTF data version. */
ctf_dynhash_t *ctf_dthash; /* Hash of dynamic type definitions. */
ctf_list_t ctf_dtdefs; /* List of dynamic type definitions. */
ctf_dynhash_t *ctf_dvhash; /* Hash of dynamic variable mappings. */
ctf_list_t ctf_dvdefs; /* List of dynamic variable definitions. */
unsigned long ctf_dtoldid; /* Oldest id that has been committed. */
unsigned long ctf_snapshots; /* ctf_snapshot() plus ctf_update() count. */
unsigned long ctf_snapshot_lu; /* ctf_snapshot() call count at last update. */
ctf_archive_t *ctf_archive; /* Archive this ctf_dict_t came from. */
ctf_list_t ctf_errs_warnings; /* CTF errors and warnings. */
ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link. */
ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link. */
/* If a link input CU, points at the corresponding per-CU output (if any);
if an output, points at the input (if any). */
ctf_dict_t *ctf_link_in_out;
/* Map input types to output types for ctf_add_type. Key is a
ctf_link_type_key_t: value is a type ID. */
ctf_dynhash_t *ctf_link_type_mapping;
/* Map input CU names to output CTF dict names: populated in the top-level
output dict.
Key and value are dynamically-allocated strings. */
ctf_dynhash_t *ctf_link_in_cu_mapping;
/* Map output CTF dict names to input CU names: populated in the top-level
output dict. A hash of string to hash (set) of strings. Key and
individual value members are shared with ctf_link_in_cu_mapping. */
ctf_dynhash_t *ctf_link_out_cu_mapping;
/* CTF linker flags. Set on the parent output dict (the one passed to
ctf_link). Only respected when LCTF_LINKING set in ctf_flags. */
int ctf_link_flags;
/* Allow the caller to change the name of link archive members. */
ctf_link_memb_name_changer_f *ctf_link_memb_name_changer;
void *ctf_link_memb_name_changer_arg; /* Argument for it. */
/* Allow the caller to filter out variables they don't care about. */
ctf_link_variable_filter_f *ctf_link_variable_filter;
void *ctf_link_variable_filter_arg; /* Argument for it. */
ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now. */
/* Atoms table for dedup string storage. All strings in the ctf_dedup_t are
stored here. Only the _alloc copy is allocated or freed: the
ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms.
We keep the atoms table outside the ctf_dedup so that atoms can be
preserved across multiple similar links, such as when doing cu-mapped
links. */
ctf_dynset_t *ctf_dedup_atoms;
ctf_dynset_t *ctf_dedup_atoms_alloc;
ctf_dedup_t ctf_dedup; /* Deduplicator state. */
char *ctf_tmp_typeslice; /* Storage for slicing up type names. */
size_t ctf_tmp_typeslicelen; /* Size of the typeslice. */
void *ctf_specific; /* Data for ctf_get/setspecific(). */
};
/* An abstraction over both a ctf_dict_t and a ctf_archive_t. */
struct ctf_archive_internal
{
int ctfi_is_archive;
int ctfi_unmap_on_close;
ctf_dict_t *ctfi_dict;
struct ctf_archive *ctfi_archive;
ctf_dynhash_t *ctfi_dicts; /* Dicts we have opened and cached. */
ctf_dict_t *ctfi_crossdict_cache; /* Cross-dict caching. */
ctf_dict_t **ctfi_symdicts; /* Array of index -> ctf_dict_t *. */
ctf_dynhash_t *ctfi_symnamedicts; /* Hash of name -> ctf_dict_t *. */
ctf_sect_t ctfi_symsect;
int ctfi_symsect_little_endian; /* -1 for unknown / do not set. */
ctf_sect_t ctfi_strsect;
int ctfi_free_symsect;
int ctfi_free_strsect;
void *ctfi_data;
bfd *ctfi_abfd; /* Optional source of section data. */
void (*ctfi_bfd_close) (struct ctf_archive_internal *);
};
/* Iterator state for the *_next() functions. */
/* A single hash key/value pair. */
typedef struct ctf_next_hkv
{
void *hkv_key;
void *hkv_value;
} ctf_next_hkv_t;
struct ctf_next
{
void (*ctn_iter_fun) (void);
ctf_id_t ctn_type;
ssize_t ctn_size;
ssize_t ctn_increment;
const ctf_type_t *ctn_tp;
uint32_t ctn_n;
/* Some iterators contain other iterators, in addition to their other
state. We allow for inner and outer iterators, for two-layer nested loops
like those found in ctf_arc_lookup_enumerator_next. */
ctf_next_t *ctn_next;
ctf_next_t *ctn_next_inner;
/* We can save space on this side of things by noting that a type is either
dynamic or not, as a whole, and a given iterator can only iterate over one
kind of thing at once: so we can overlap the DTD and non-DTD members, and
the structure, variable and enum members, etc. */
union
{
unsigned char *ctn_vlen;
const ctf_enum_t *ctn_en;
const ctf_dvdef_t *ctn_dvd;
ctf_next_hkv_t *ctn_sorted_hkv;
void **ctn_hash_slot;
} u;
/* This union is of various sorts of dict we can iterate over: currently
archives, dictionaries, dynhashes, and dynsets. ctn_fp is non-const
because we need to set errors on it. */
union
{
ctf_dict_t *ctn_fp;
const ctf_archive_t *ctn_arc;
const ctf_dynhash_t *ctn_h;
const ctf_dynset_t *ctn_s;
} cu;
};
extern uint32_t ctf_type_to_index (const ctf_dict_t *, ctf_id_t);
extern ctf_id_t ctf_index_to_type (const ctf_dict_t *, uint32_t);
/* Return x rounded up to an alignment boundary.
eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align) */
#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
/* * If an offs is not aligned already then round it up and align it. */
#define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
#define LCTF_INDEX_TO_TYPEPTR(fp, i) \
((i > fp->ctf_stypes) ? \
&(ctf_dtd_lookup (fp, ctf_index_to_type (fp, i))->dtd_data) : \
(ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
#define LCTF_INFO_KIND(fp, info) ((fp)->ctf_dictops->ctfo_get_kind(info))
#define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_dictops->ctfo_get_root(info))
#define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_dictops->ctfo_get_vlen(info))
#define LCTF_VBYTES(fp, kind, size, vlen) \
((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen))
#define LCTF_CHILD 0x0001 /* CTF dict is a child. */
#define LCTF_LINKING 0x0002 /* CTF link is underway: respect ctf_link_flags. */
#define LCTF_STRICT_NO_DUP_ENUMERATORS 0x0004 /* Duplicate enums prohibited. */
#define LCTF_NO_STR 0x0008 /* No string lookup possible yet. */
#define LCTF_NO_TYPE 0x0010 /* No type additions possible. */
#define LCTF_PRESERIALIZED 0x0020 /* Already serialized all but the strtab. */
extern ctf_dynhash_t *ctf_name_table (ctf_dict_t *, int);
extern const ctf_type_t *ctf_lookup_by_id (ctf_dict_t **, ctf_id_t);
extern ctf_id_t ctf_lookup_variable_here (ctf_dict_t *fp, const char *name);
extern ctf_id_t ctf_lookup_by_sym_or_name (ctf_dict_t *, unsigned long symidx,
const char *symname, int try_parent,
int is_function);
extern ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *, int, const char *);
extern void ctf_set_ctl_hashes (ctf_dict_t *);
extern ctf_id_t ctf_symbol_next_static (ctf_dict_t *, ctf_next_t **,
const char **, int);
extern int ctf_symtab_skippable (ctf_link_sym_t *sym);
extern int ctf_add_funcobjt_sym (ctf_dict_t *, int is_function,
const char *, ctf_id_t);
extern ctf_dict_t *ctf_get_dict (const ctf_dict_t *fp, ctf_id_t type);
typedef unsigned int (*ctf_hash_fun) (const void *ptr);
extern unsigned int ctf_hash_integer (const void *ptr);
extern unsigned int ctf_hash_string (const void *ptr);
extern unsigned int ctf_hash_type_key (const void *ptr);
extern unsigned int ctf_hash_type_id_key (const void *ptr);
typedef int (*ctf_hash_eq_fun) (const void *, const void *);
extern int ctf_hash_eq_integer (const void *, const void *);
extern int ctf_hash_eq_string (const void *, const void *);
extern int ctf_hash_eq_type_key (const void *, const void *);
extern int ctf_hash_eq_type_id_key (const void *, const void *);
/* Freeing functions. ctf_hash_free_fun is used unless the arg
parameter to ctf_dynhash_create_{arg,sized} is non-NULL.
There is no way to pass a NULL arg to ctf_hash_free_arg_fun. */
typedef void (*ctf_hash_free_fun) (void *);
typedef void (*ctf_hash_free_arg_fun) (void *, void *);
typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg);
typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg);
typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg);
typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *,
void *arg);
extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun,
ctf_hash_free_fun, ctf_hash_free_fun);
extern ctf_dynhash_t *ctf_dynhash_create_arg (ctf_hash_fun, ctf_hash_eq_fun,
ctf_hash_free_arg_fun,
ctf_hash_free_arg_fun, void *);
extern ctf_dynhash_t *ctf_dynhash_create_sized (unsigned long, ctf_hash_fun,
ctf_hash_eq_fun,
ctf_hash_free_arg_fun,
ctf_hash_free_arg_fun,
void *);
extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
extern size_t ctf_dynhash_elements (ctf_dynhash_t *);
extern void ctf_dynhash_empty (ctf_dynhash_t *);
extern int ctf_dynhash_insert_type (ctf_dict_t *, ctf_dynhash_t *, uint32_t, uint32_t);
extern ctf_id_t ctf_dynhash_lookup_type (ctf_dynhash_t *, const char *);
extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key,
const void **orig_key, void **value);
extern void ctf_dynhash_destroy (ctf_dynhash_t *);
extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *);
extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f,
void *);
extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f,
void *);
extern int ctf_dynhash_sort_by_name (const ctf_next_hkv_t *,
const ctf_next_hkv_t *,
void * _libctf_unused_);
extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **,
void **key, void **value);
extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **,
void **key, void **value, ctf_hash_sort_f,
void *);
extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun);
extern int ctf_dynset_insert (ctf_dynset_t *, void *);
extern void ctf_dynset_remove (ctf_dynset_t *, const void *);
extern size_t ctf_dynset_elements (ctf_dynset_t *);
extern void ctf_dynset_destroy (ctf_dynset_t *);
extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *);
extern int ctf_dynset_exists (ctf_dynset_t *, const void *key,
const void **orig_key);
extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key);
extern void *ctf_dynset_lookup_any (ctf_dynset_t *);
extern void ctf_sha1_init (ctf_sha1_t *);
extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t);
extern char *ctf_sha1_fini (ctf_sha1_t *, char *);
#define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev))
#define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next))
extern void ctf_list_append (ctf_list_t *, void *);
extern void ctf_list_prepend (ctf_list_t *, void *);
extern void ctf_list_delete (ctf_list_t *, void *);
extern void ctf_list_splice (ctf_list_t *, ctf_list_t *);
extern int ctf_list_empty_p (ctf_list_t *lp);
extern int ctf_dtd_insert (ctf_dict_t *, ctf_dtdef_t *, int flag, int kind);
extern void ctf_dtd_delete (ctf_dict_t *, ctf_dtdef_t *);
extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_dict_t *, ctf_id_t);
extern ctf_dtdef_t *ctf_dynamic_type (const ctf_dict_t *, ctf_id_t);
extern int ctf_dvd_insert (ctf_dict_t *, ctf_dvdef_t *);
extern void ctf_dvd_delete (ctf_dict_t *, ctf_dvdef_t *);
extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_dict_t *, const char *);
extern ctf_id_t ctf_add_encoded (ctf_dict_t *, uint32_t, const char *,
const ctf_encoding_t *, uint32_t kind);
extern ctf_id_t ctf_add_reftype (ctf_dict_t *, uint32_t, ctf_id_t,
uint32_t kind);
extern int ctf_add_variable_forced (ctf_dict_t *, const char *, ctf_id_t);
extern int ctf_add_funcobjt_sym_forced (ctf_dict_t *, int is_function,
const char *, ctf_id_t);
extern int ctf_track_enumerator (ctf_dict_t *, ctf_id_t, const char *);
extern int ctf_dedup_atoms_init (ctf_dict_t *);
extern int ctf_dedup (ctf_dict_t *, ctf_dict_t **, uint32_t ninputs,
int cu_mapped);
extern ctf_dict_t **ctf_dedup_emit (ctf_dict_t *, ctf_dict_t **,
uint32_t ninputs, uint32_t *parents,
uint32_t *noutputs, int cu_mapped);
extern int ctf_dedup_strings (ctf_dict_t *fp);
extern void ctf_dedup_fini (ctf_dict_t *, ctf_dict_t **, uint32_t);
extern ctf_id_t ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp,
ctf_id_t src_type);
extern void ctf_decl_init (ctf_decl_t *);
extern void ctf_decl_fini (ctf_decl_t *);
extern void ctf_decl_push (ctf_decl_t *, ctf_dict_t *, ctf_id_t);
_libctf_printflike_ (2, 3)
extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...);
extern char *ctf_decl_buf (ctf_decl_t *cd);
extern const char *ctf_strptr (ctf_dict_t *, uint32_t);
extern const char *ctf_strraw (ctf_dict_t *, uint32_t);
extern const char *ctf_strraw_explicit (ctf_dict_t *, uint32_t,
ctf_strs_t *);
extern const char *ctf_strptr_validate (ctf_dict_t *, uint32_t);
extern int ctf_str_create_atoms (ctf_dict_t *);
extern void ctf_str_free_atoms (ctf_dict_t *);
extern uint32_t ctf_str_add (ctf_dict_t *, const char *);
extern uint32_t ctf_str_add_copy (ctf_dict_t *, const char *);
extern int ctf_str_add_external (ctf_dict_t *, const char *, uint32_t offset);
extern void ctf_str_purge_refs (ctf_dict_t *fp);
extern void ctf_str_rollback (ctf_dict_t *, ctf_snapshot_id_t);
extern const ctf_strs_writable_t *ctf_str_write_strtab (ctf_dict_t *);
extern int ctf_preserialize (ctf_dict_t *fp);
extern void ctf_depreserialize (ctf_dict_t *fp);
extern struct ctf_archive_internal *
ctf_new_archive_internal (int is_archive, int unmap_on_close,
struct ctf_archive *, ctf_dict_t *,
const ctf_sect_t *symsect,
const ctf_sect_t *strsect, int *errp);
extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
extern void ctf_arc_close_internal (struct ctf_archive *);
extern const ctf_preamble_t *ctf_arc_bufpreamble (const ctf_sect_t *);
extern void *ctf_set_open_errno (int *, int);
extern void ctf_flip_header (ctf_header_t *);
extern int ctf_flip (ctf_dict_t *, ctf_header_t *, unsigned char *, int);
extern int ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp);
extern int ctf_write_thresholded (ctf_dict_t *fp, int fd, size_t threshold);
_libctf_malloc_
extern void *ctf_mmap (size_t length, size_t offset, int fd);
extern void ctf_munmap (void *, size_t);
extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
extern char *ctf_str_append (char *, const char *);
extern char *ctf_str_append_noerr (char *, const char *);
extern ctf_id_t ctf_type_resolve_unsliced (ctf_dict_t *, ctf_id_t);
extern int ctf_type_kind_unsliced (ctf_dict_t *, ctf_id_t);
_libctf_printflike_ (1, 2)
extern void ctf_dprintf (const char *, ...);
extern void libctf_init_debug (void);
_libctf_printflike_ (4, 5)
extern void ctf_err_warn (ctf_dict_t *, int is_warning, int err,
const char *, ...);
extern void ctf_err_warn_to_open (ctf_dict_t *);
extern void ctf_err_copy (ctf_dict_t *dest, ctf_dict_t *src);
extern void ctf_assert_fail_internal (ctf_dict_t *, const char *,
size_t, const char *);
extern const char *ctf_link_input_name (ctf_dict_t *);
extern ctf_link_sym_t *ctf_elf32_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst,
const Elf32_Sym *src, uint32_t symidx);
extern ctf_link_sym_t *ctf_elf64_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst,
const Elf64_Sym *src, uint32_t symidx);
/* Variables, all underscore-prepended. */
extern const char _CTF_SECTION[]; /* name of CTF ELF section */
extern const char _CTF_NULLSTR[]; /* empty string */
extern int _libctf_version; /* library client version */
extern int _libctf_debug; /* debugging messages enabled */
#include "ctf-inlines.h"
#ifdef __cplusplus
}
#endif
#endif /* _CTF_IMPL_H */
View Git Blame Copy Permalink