mirror of
https://github.com/espressif/binutils-gdb.git
synced 2025-05-23 10:17:53 +08:00
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.
This commit is contained in:
Nick Alcock
@ -123,15 +123,15 @@ typedef struct ctf_lookup
|
||||
ctf_names_t *ctl_hash; /* Pointer to hash table for lookup. */
|
||||
} ctf_lookup_t;
|
||||
|
||||
typedef struct ctf_fileops
|
||||
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_file_t *, const ctf_type_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_file_t *, unsigned short, ssize_t, size_t);
|
||||
} ctf_fileops_t;
|
||||
ssize_t (*ctfo_get_vbytes) (ctf_dict_t *, unsigned short, ssize_t, size_t);
|
||||
} ctf_dictops_t;
|
||||
|
||||
typedef struct ctf_list
|
||||
{
|
||||
@ -237,11 +237,11 @@ typedef struct ctf_str_atom_ref
|
||||
|
||||
typedef struct ctf_link_type_key
|
||||
{
|
||||
ctf_file_t *cltk_fp;
|
||||
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_file_t on 32-bit platforms. */
|
||||
/* 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;
|
||||
@ -253,7 +253,7 @@ typedef struct ctf_type_id_key
|
||||
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_file_t (by array index in an array of inputs) and
|
||||
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
|
||||
@ -272,10 +272,10 @@ typedef struct ctf_dedup
|
||||
|
||||
/* 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_file_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 file for the former and the real
|
||||
(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];
|
||||
@ -339,25 +339,26 @@ typedef struct ctf_dedup
|
||||
|
||||
/* Points to the output counterpart of this input dictionary, at emission
|
||||
time. */
|
||||
ctf_file_t *cd_output;
|
||||
ctf_dict_t *cd_output;
|
||||
} ctf_dedup_t;
|
||||
|
||||
/* The ctf_file is the structure used to represent a CTF container to library
|
||||
/* 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_file_t typedef appears in <ctf-api.h> and declares a forward tag.
|
||||
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.)
|
||||
|
||||
NOTE: ctf_update() requires that everything inside of ctf_file either be an
|
||||
immediate value, a pointer to dynamically allocated data *outside* of the
|
||||
ctf_file itself, or a pointer to statically allocated data. If you add a
|
||||
pointer to ctf_file that points to something within the ctf_file itself,
|
||||
you must make corresponding changes to ctf_update(). */
|
||||
NOTE: ctf_serialize() requires that everything inside of ctf_dict either be
|
||||
an immediate value, a pointer to dynamically allocated data *outside* of the
|
||||
ctf_dict itself, or a pointer to statically allocated data. If you add a
|
||||
pointer to ctf_dict that points to something within the ctf_dict itself, you
|
||||
must make corresponding changes to ctf_serialize(). */
|
||||
|
||||
struct ctf_file
|
||||
struct ctf_dict
|
||||
{
|
||||
const ctf_fileops_t *ctf_fileops; /* Version-specific file operations. */
|
||||
struct ctf_header *ctf_header; /* The header from this CTF file. */
|
||||
unsigned char ctf_openflags; /* Flags the file had when opened. */
|
||||
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_symtab; /* Symbol table from object file. */
|
||||
ctf_sect_t ctf_strtab; /* String table from object file. */
|
||||
@ -390,9 +391,9 @@ struct ctf_file
|
||||
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_file *ctf_parent; /* Parent CTF container (if any). */
|
||||
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 container (if any). */
|
||||
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_parmax; /* Highest type ID of a parent type. */
|
||||
@ -407,7 +408,7 @@ struct ctf_file
|
||||
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_file_t came from. */
|
||||
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. */
|
||||
@ -457,13 +458,13 @@ struct ctf_file
|
||||
void *ctf_specific; /* Data for ctf_get/setspecific(). */
|
||||
};
|
||||
|
||||
/* An abstraction over both a ctf_file_t and a ctf_archive_t. */
|
||||
/* 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_file_t *ctfi_file;
|
||||
ctf_dict_t *ctfi_dict;
|
||||
struct ctf_archive *ctfi_archive;
|
||||
ctf_sect_t ctfi_symsect;
|
||||
ctf_sect_t ctfi_strsect;
|
||||
@ -490,7 +491,7 @@ struct ctf_next
|
||||
ssize_t ctn_size;
|
||||
ssize_t ctn_increment;
|
||||
uint32_t ctn_n;
|
||||
/* We can save space on this side of things by noting that a container is
|
||||
/* We can save space on this side of things by noting that a dictionary 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. */
|
||||
@ -504,11 +505,11 @@ struct ctf_next
|
||||
ctf_next_hkv_t *ctn_sorted_hkv;
|
||||
void **ctn_hash_slot;
|
||||
} u;
|
||||
/* This union is of various sorts of container we can iterate over:
|
||||
/* This union is of various sorts of dict we can iterate over:
|
||||
currently dictionaries and archives, dynhashes, and dynsets. */
|
||||
union
|
||||
{
|
||||
const ctf_file_t *ctn_fp;
|
||||
const ctf_dict_t *ctn_fp;
|
||||
const ctf_archive_t *ctn_arc;
|
||||
const ctf_dynhash_t *ctn_h;
|
||||
const ctf_dynset_t *ctn_s;
|
||||
@ -535,23 +536,23 @@ struct ctf_next
|
||||
(fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \
|
||||
(ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
|
||||
|
||||
#define LCTF_INFO_KIND(fp, info) ((fp)->ctf_fileops->ctfo_get_kind(info))
|
||||
#define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_fileops->ctfo_get_root(info))
|
||||
#define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_fileops->ctfo_get_vlen(info))
|
||||
#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_fileops->ctfo_get_vbytes(fp, kind, size, vlen))
|
||||
((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen))
|
||||
|
||||
#define LCTF_CHILD 0x0001 /* CTF container is a child */
|
||||
#define LCTF_RDWR 0x0002 /* CTF container is writable */
|
||||
#define LCTF_DIRTY 0x0004 /* CTF container has been modified */
|
||||
#define LCTF_CHILD 0x0001 /* CTF dict is a child */
|
||||
#define LCTF_RDWR 0x0002 /* CTF dict is writable */
|
||||
#define LCTF_DIRTY 0x0004 /* CTF dict has been modified */
|
||||
|
||||
extern ctf_names_t *ctf_name_table (ctf_file_t *, int);
|
||||
extern const ctf_type_t *ctf_lookup_by_id (ctf_file_t **, ctf_id_t);
|
||||
extern ctf_id_t ctf_lookup_by_rawname (ctf_file_t *, int, const char *);
|
||||
extern ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *, ctf_names_t *, const char *);
|
||||
extern void ctf_set_ctl_hashes (ctf_file_t *);
|
||||
extern ctf_names_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_by_rawname (ctf_dict_t *, int, const char *);
|
||||
extern ctf_id_t ctf_lookup_by_rawhash (ctf_dict_t *, ctf_names_t *, const char *);
|
||||
extern void ctf_set_ctl_hashes (ctf_dict_t *);
|
||||
|
||||
extern ctf_file_t *ctf_get_dict (ctf_file_t *fp, ctf_id_t type);
|
||||
extern ctf_dict_t *ctf_get_dict (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);
|
||||
@ -576,9 +577,9 @@ typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *,
|
||||
void *arg);
|
||||
|
||||
extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun);
|
||||
extern int ctf_hash_insert_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
|
||||
extern int ctf_hash_define_type (ctf_hash_t *, ctf_file_t *, uint32_t, uint32_t);
|
||||
extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_file_t *, const char *);
|
||||
extern int ctf_hash_insert_type (ctf_hash_t *, ctf_dict_t *, uint32_t, uint32_t);
|
||||
extern int ctf_hash_define_type (ctf_hash_t *, ctf_dict_t *, uint32_t, uint32_t);
|
||||
extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_dict_t *, const char *);
|
||||
extern uint32_t ctf_hash_size (const ctf_hash_t *);
|
||||
extern void ctf_hash_destroy (ctf_hash_t *);
|
||||
|
||||
@ -626,101 +627,101 @@ 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_file_t *, ctf_dtdef_t *, int flag, int kind);
|
||||
extern void ctf_dtd_delete (ctf_file_t *, ctf_dtdef_t *);
|
||||
extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_file_t *, ctf_id_t);
|
||||
extern ctf_dtdef_t *ctf_dynamic_type (const ctf_file_t *, ctf_id_t);
|
||||
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_file_t *, ctf_dvdef_t *);
|
||||
extern void ctf_dvd_delete (ctf_file_t *, ctf_dvdef_t *);
|
||||
extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_file_t *, const char *);
|
||||
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_file_t *, uint32_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_file_t *, uint32_t, ctf_id_t,
|
||||
extern ctf_id_t ctf_add_reftype (ctf_dict_t *, uint32_t, ctf_id_t,
|
||||
uint32_t kind);
|
||||
|
||||
extern void ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
|
||||
ctf_file_t *dst_fp, ctf_id_t dst_type);
|
||||
extern ctf_id_t ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
|
||||
ctf_file_t **dst_fp);
|
||||
extern void ctf_add_type_mapping (ctf_dict_t *src_fp, ctf_id_t src_type,
|
||||
ctf_dict_t *dst_fp, ctf_id_t dst_type);
|
||||
extern ctf_id_t ctf_type_mapping (ctf_dict_t *src_fp, ctf_id_t src_type,
|
||||
ctf_dict_t **dst_fp);
|
||||
|
||||
extern int ctf_dedup_atoms_init (ctf_file_t *);
|
||||
extern int ctf_dedup (ctf_file_t *, ctf_file_t **, uint32_t ninputs,
|
||||
extern int ctf_dedup_atoms_init (ctf_dict_t *);
|
||||
extern int ctf_dedup (ctf_dict_t *, ctf_dict_t **, uint32_t ninputs,
|
||||
uint32_t *parents, int cu_mapped);
|
||||
extern void ctf_dedup_fini (ctf_file_t *, ctf_file_t **, uint32_t);
|
||||
extern ctf_file_t **ctf_dedup_emit (ctf_file_t *, ctf_file_t **,
|
||||
extern void ctf_dedup_fini (ctf_dict_t *, ctf_dict_t **, uint32_t);
|
||||
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 void ctf_decl_init (ctf_decl_t *);
|
||||
extern void ctf_decl_fini (ctf_decl_t *);
|
||||
extern void ctf_decl_push (ctf_decl_t *, ctf_file_t *, ctf_id_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_file_t *, uint32_t);
|
||||
extern const char *ctf_strraw (ctf_file_t *, uint32_t);
|
||||
extern const char *ctf_strraw_explicit (ctf_file_t *, uint32_t,
|
||||
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 int ctf_str_create_atoms (ctf_file_t *);
|
||||
extern void ctf_str_free_atoms (ctf_file_t *);
|
||||
extern uint32_t ctf_str_add (ctf_file_t *, const char *);
|
||||
extern uint32_t ctf_str_add_ref (ctf_file_t *, const char *, uint32_t *ref);
|
||||
extern int ctf_str_add_external (ctf_file_t *, const char *, uint32_t offset);
|
||||
extern void ctf_str_remove_ref (ctf_file_t *, const char *, uint32_t *ref);
|
||||
extern void ctf_str_rollback (ctf_file_t *, ctf_snapshot_id_t);
|
||||
extern void ctf_str_purge_refs (ctf_file_t *);
|
||||
extern ctf_strs_writable_t ctf_str_write_strtab (ctf_file_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_ref (ctf_dict_t *, const char *, uint32_t *ref);
|
||||
extern int ctf_str_add_external (ctf_dict_t *, const char *, uint32_t offset);
|
||||
extern void ctf_str_remove_ref (ctf_dict_t *, const char *, uint32_t *ref);
|
||||
extern void ctf_str_rollback (ctf_dict_t *, ctf_snapshot_id_t);
|
||||
extern void ctf_str_purge_refs (ctf_dict_t *);
|
||||
extern ctf_strs_writable_t ctf_str_write_strtab (ctf_dict_t *);
|
||||
|
||||
extern struct ctf_archive_internal *
|
||||
ctf_new_archive_internal (int is_archive, int unmap_on_close,
|
||||
struct ctf_archive *, ctf_file_t *,
|
||||
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 void *ctf_set_open_errno (int *, int);
|
||||
extern unsigned long ctf_set_errno (ctf_file_t *, int);
|
||||
extern unsigned long ctf_set_errno (ctf_dict_t *, int);
|
||||
|
||||
extern ctf_file_t *ctf_simple_open_internal (const char *, size_t, const char *,
|
||||
extern ctf_dict_t *ctf_simple_open_internal (const char *, size_t, const char *,
|
||||
size_t, size_t,
|
||||
const char *, size_t,
|
||||
ctf_dynhash_t *, int, int *);
|
||||
extern ctf_file_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *,
|
||||
extern ctf_dict_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *,
|
||||
const ctf_sect_t *, ctf_dynhash_t *,
|
||||
int, int *);
|
||||
extern int ctf_import_unref (ctf_file_t *fp, ctf_file_t *pfp);
|
||||
extern int ctf_serialize (ctf_file_t *);
|
||||
extern int ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp);
|
||||
extern int ctf_serialize (ctf_dict_t *);
|
||||
|
||||
_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 void *ctf_realloc (ctf_file_t *, void *, size_t);
|
||||
extern void *ctf_realloc (ctf_dict_t *, void *, size_t);
|
||||
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_file_t *, ctf_id_t);
|
||||
extern int ctf_type_kind_unsliced (ctf_file_t *, ctf_id_t);
|
||||
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_file_t *, int is_warning, int err,
|
||||
extern void ctf_err_warn (ctf_dict_t *, int is_warning, int err,
|
||||
const char *, ...);
|
||||
extern void ctf_err_warn_to_open (ctf_file_t *);
|
||||
extern void ctf_assert_fail_internal (ctf_file_t *, const char *,
|
||||
extern void ctf_err_warn_to_open (ctf_dict_t *);
|
||||
extern void ctf_assert_fail_internal (ctf_dict_t *, const char *,
|
||||
size_t, const char *);
|
||||
extern const char *ctf_link_input_name (ctf_file_t *);
|
||||
extern const char *ctf_link_input_name (ctf_dict_t *);
|
||||
|
||||
extern Elf64_Sym *ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst);
|
||||
extern const char *ctf_lookup_symbol_name (ctf_file_t *fp, unsigned long symidx);
|
||||
extern const char *ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx);
|
||||
|
||||
/* Variables, all underscore-prepended. */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user