From 139633c307eb6f5746ea04f94a0b6382e51bccb9 Mon Sep 17 00:00:00 2001 From: Nick Alcock Date: Fri, 20 Nov 2020 13:34:04 +0000 Subject: 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 * 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 * 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 * 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) : Rename to... : ... this. ld/ChangeLog 2020-11-20 Nick Alcock * 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 * ctf-impl.h: Rename ctf_file_t to ctf_dict_t: all declarations adjusted. (ctf_fileops): Rename to... (ctf_dictops): ... this. (ctf_dedup_t) : Rename to... : ... this. (ctf_file_t): Fix outdated comment. : Rename to... : ... this. (struct ctf_archive_internal) : Rename to... : ... 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) : Rename to... ctf_dedup.cd_id_to_file_t, + if (!ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_dict_t, &key, &lookup, NULL)) { if ((dynkey = malloc (sizeof (ctf_type_id_key_t))) == NULL) goto oom; memcpy (dynkey, &key, sizeof (ctf_type_id_key_t)); - if (ctf_dynhash_insert (fp->ctf_dedup.cd_id_to_file_t, dynkey, NULL) < 0) + if (ctf_dynhash_insert (fp->ctf_dedup.cd_id_to_dict_t, dynkey, NULL) < 0) goto oom; - ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_file_t, + ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_dict_t, dynkey, &lookup, NULL); } /* We use a raw assert() here because there isn't really a way to get any sort @@ -368,7 +368,7 @@ make_set_element (ctf_dynhash_t *set, const void *key) /* Initialize the dedup atoms table. */ int -ctf_dedup_atoms_init (ctf_file_t *fp) +ctf_dedup_atoms_init (ctf_dict_t *fp) { if (fp->ctf_dedup_atoms) return 0; @@ -387,7 +387,7 @@ ctf_dedup_atoms_init (ctf_file_t *fp) /* Intern things in the dedup atoms table. */ static const char * -intern (ctf_file_t *fp, char *atom) +intern (ctf_dict_t *fp, char *atom) { const void *foo; @@ -414,7 +414,7 @@ intern (ctf_file_t *fp, char *atom) while allowing for the four C namespaces (normal, struct, union, enum). Return a new dynamically-allocated string. */ static const char * -ctf_decorate_type_name (ctf_file_t *fp, const char *name, int kind) +ctf_decorate_type_name (ctf_dict_t *fp, const char *name, int kind) { ctf_dedup_t *d = &fp->ctf_dedup; const char *ret; @@ -484,13 +484,13 @@ ctf_dedup_sha1_add (ctf_sha1_t *sha1, const void *buf, size_t len, } static const char * -ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, - ctf_file_t **inputs, uint32_t *parents, +ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input, + ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -519,7 +519,7 @@ ctf_dedup_is_stub (const char *name, int kind, int fwdkind, int flags) Only called for forwards or forwardable types with names, when the link mode is CTF_LINK_SHARE_DUPLICATED. */ static int -ctf_dedup_record_origin (ctf_file_t *fp, int input_num, const char *decorated, +ctf_dedup_record_origin (ctf_dict_t *fp, int input_num, const char *decorated, void *id) { ctf_dedup_t *d = &fp->ctf_dedup; @@ -551,14 +551,14 @@ ctf_dedup_record_origin (ctf_file_t *fp, int input_num, const char *decorated, calls, recursively). */ static const char * -ctf_dedup_rhash_type (ctf_file_t *fp, ctf_file_t *input, ctf_file_t **inputs, +ctf_dedup_rhash_type (ctf_dict_t *fp, ctf_dict_t *input, ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, void *type_id, const ctf_type_t *tp, const char *name, const char *decorated, int kind, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -990,13 +990,13 @@ ctf_dedup_rhash_type (ctf_file_t *fp, ctf_file_t *input, ctf_file_t **inputs, Returns a hash value (an atom), or NULL on error. */ static const char * -ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, - ctf_file_t **inputs, uint32_t *parents, +ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input, + ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -1139,8 +1139,8 @@ ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, cd_output_first_tu mapping. */ static int -ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, - ctf_file_t **inputs _libctf_unused_, +ctf_dedup_populate_mappings (ctf_dict_t *fp, ctf_dict_t *input _libctf_unused_, + ctf_dict_t **inputs _libctf_unused_, int input_num _libctf_unused_, ctf_id_t type _libctf_unused_, void *id, const char *decorated_name, @@ -1212,7 +1212,7 @@ ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, while ((err = ctf_dynset_cnext (type_ids, &i, &one_id)) == 0) { - ctf_file_t *foo = inputs[CTF_DEDUP_GID_TO_INPUT (one_id)]; + ctf_dict_t *foo = inputs[CTF_DEDUP_GID_TO_INPUT (one_id)]; ctf_id_t bar = CTF_DEDUP_GID_TO_TYPE (one_id); if (ctf_type_kind_unsliced (foo, bar) != orig_kind) { @@ -1285,7 +1285,7 @@ ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, ctf_dedup_maybe_synthesize_forward.) */ static int -ctf_dedup_mark_conflicting_hash (ctf_file_t *fp, const char *hval) +ctf_dedup_mark_conflicting_hash (ctf_dict_t *fp, const char *hval) { ctf_dedup_t *d = &fp->ctf_dedup; ctf_next_t *i = NULL; @@ -1331,7 +1331,7 @@ ctf_dedup_mark_conflicting_hash (ctf_file_t *fp, const char *hval) /* Look up a type kind from the output mapping, given a type hash value. */ static int -ctf_dedup_hash_kind (ctf_file_t *fp, ctf_file_t **inputs, const char *hash) +ctf_dedup_hash_kind (ctf_dict_t *fp, ctf_dict_t **inputs, const char *hash) { ctf_dedup_t *d = &fp->ctf_dedup; void *id; @@ -1363,8 +1363,8 @@ ctf_dedup_hash_kind (ctf_file_t *fp, ctf_file_t **inputs, const char *hash) /* Used to keep a count of types: i.e. distinct type hash values. */ typedef struct ctf_dedup_type_counter { - ctf_file_t *fp; - ctf_file_t **inputs; + ctf_dict_t *fp; + ctf_dict_t **inputs; int num_non_forwards; } ctf_dedup_type_counter_t; @@ -1401,7 +1401,7 @@ ctf_dedup_count_types (void *key_, void *value _libctf_unused_, void *arg_) /* Detect name ambiguity and mark ambiguous names as conflicting, other than the most common. */ static int -ctf_dedup_detect_name_ambiguity (ctf_file_t *fp, ctf_file_t **inputs) +ctf_dedup_detect_name_ambiguity (ctf_dict_t *fp, ctf_dict_t **inputs) { ctf_dedup_t *d = &fp->ctf_dedup; ctf_next_t *i = NULL; @@ -1560,7 +1560,7 @@ ctf_dedup_detect_name_ambiguity (ctf_file_t *fp, ctf_file_t **inputs) /* Initialize the deduplication machinery. */ static int -ctf_dedup_init (ctf_file_t *fp) +ctf_dedup_init (ctf_dict_t *fp) { ctf_dedup_t *d = &fp->ctf_dedup; size_t i; @@ -1569,7 +1569,7 @@ ctf_dedup_init (ctf_file_t *fp) goto oom; #if IDS_NEED_ALLOCATION - if ((d->cd_id_to_file_t = ctf_dynhash_create (ctf_hash_type_id_key, + if ((d->cd_id_to_dict_t = ctf_dynhash_create (ctf_hash_type_id_key, ctf_hash_eq_type_id_key, free, NULL)) == NULL) goto oom; @@ -1646,14 +1646,14 @@ ctf_dedup_init (ctf_file_t *fp) } void -ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) +ctf_dedup_fini (ctf_dict_t *fp, ctf_dict_t **outputs, uint32_t noutputs) { ctf_dedup_t *d = &fp->ctf_dedup; size_t i; /* ctf_dedup_atoms is kept across links. */ #if IDS_NEED_ALLOCATION - ctf_dynhash_destroy (d->cd_id_to_file_t); + ctf_dynhash_destroy (d->cd_id_to_dict_t); #endif for (i = 0; i < 4; i++) ctf_dynhash_destroy (d->cd_decorated_names[i]); @@ -1677,7 +1677,7 @@ ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) ctf_dedup_t *od = &outputs[i]->ctf_dedup; ctf_dynhash_destroy (od->cd_output_emission_hashes); ctf_dynhash_destroy (od->cd_output_emission_conflicted_forwards); - ctf_file_close (od->cd_output); + ctf_dict_close (od->cd_output); } } memset (d, 0, sizeof (ctf_dedup_t)); @@ -1686,16 +1686,16 @@ ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) /* Return 1 if this type is cited by multiple input dictionaries. */ static int -ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_multiple_input_dicts (ctf_dict_t *output, ctf_dict_t **inputs, const char *hval) { ctf_dedup_t *d = &output->ctf_dedup; ctf_dynset_t *type_ids; ctf_next_t *i = NULL; void *id; - ctf_file_t *found = NULL, *relative_found = NULL; + ctf_dict_t *found = NULL, *relative_found = NULL; const char *type_id; - ctf_file_t *input_fp; + ctf_dict_t *input_fp; ctf_id_t input_id; const char *name; const char *decorated; @@ -1714,7 +1714,7 @@ ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, while ((err = ctf_dynset_next (type_ids, &i, &id)) == 0) { - ctf_file_t *fp = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; + ctf_dict_t *fp = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; if (fp == found || fp == relative_found) continue; @@ -1781,7 +1781,7 @@ ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, types. Only used if the link mode is CTF_LINK_SHARE_DUPLICATED. */ static int -ctf_dedup_conflictify_unshared (ctf_file_t *output, ctf_file_t **inputs) +ctf_dedup_conflictify_unshared (ctf_dict_t *output, ctf_dict_t **inputs) { ctf_dedup_t *d = &output->ctf_dedup; ctf_next_t *i = NULL; @@ -1853,7 +1853,7 @@ ctf_dedup_conflictify_unshared (ctf_file_t *output, ctf_file_t **inputs) ctf_dedup_emit afterwards to do that. */ int -ctf_dedup (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, +ctf_dedup (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int cu_mapped) { ctf_dedup_t *d = &output->ctf_dedup; @@ -1924,17 +1924,17 @@ ctf_dedup (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, } static int -ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_rwalk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -1944,19 +1944,19 @@ ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, /* Like ctf_dedup_rwalk_output_mapping (which see), only takes a single target type and visits it. */ static int -ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, - ctf_file_t **inputs, uint32_t ninputs, +ctf_dedup_rwalk_one_output_mapping (ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, int visited, void *type_id, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -1964,7 +1964,7 @@ ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, void *arg, unsigned long depth) { ctf_dedup_t *d = &output->ctf_dedup; - ctf_file_t *fp; + ctf_dict_t *fp; int input_num; ctf_id_t type; int ret; @@ -2128,17 +2128,17 @@ ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, once, but are not recursed through repeatedly: ALREADY_VISITED tracks whether types have already been visited. */ static int -ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_rwalk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -2222,7 +2222,7 @@ ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, typedef struct ctf_sort_om_cb_arg { - ctf_file_t **inputs; + ctf_dict_t **inputs; uint32_t ninputs; ctf_dedup_t *d; } ctf_sort_om_cb_arg_t; @@ -2241,8 +2241,8 @@ sort_output_mapping (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two, void *one_gid, *two_gid; uint32_t one_ninput; uint32_t two_ninput; - ctf_file_t *one_fp; - ctf_file_t *two_fp; + ctf_dict_t *one_fp; + ctf_dict_t *two_fp; ctf_id_t one_type; ctf_id_t two_type; @@ -2288,15 +2288,15 @@ sort_output_mapping (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two, /* The public entry point to ctf_dedup_rwalk_output_mapping, above. */ static int -ctf_dedup_walk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_walk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -2351,8 +2351,8 @@ ctf_dedup_walk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, conflicted per-TU type ID in INPUT with hash HVAL. Return its CTF ID, or 0 if none was needed. */ static ctf_id_t -ctf_dedup_maybe_synthesize_forward (ctf_file_t *output, ctf_file_t *target, - ctf_file_t *input, ctf_id_t id, +ctf_dedup_maybe_synthesize_forward (ctf_dict_t *output, ctf_dict_t *target, + ctf_dict_t *input, ctf_id_t id, const char *hval) { ctf_dedup_t *od = &output->ctf_dedup; @@ -2430,14 +2430,14 @@ ctf_dedup_maybe_synthesize_forward (ctf_file_t *output, ctf_file_t *target, make usability a bit better. */ static ctf_id_t -ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, - ctf_file_t **inputs, uint32_t ninputs, - uint32_t *parents, ctf_file_t *input, int input_num, +ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target, + ctf_dict_t **inputs, uint32_t ninputs, + uint32_t *parents, ctf_dict_t *input, int input_num, ctf_id_t id) { ctf_dedup_t *od = &output->ctf_dedup; ctf_dedup_t *td = &target->ctf_dedup; - ctf_file_t *err_fp = input; + ctf_dict_t *err_fp = input; const char *hval; void *target_id; ctf_id_t emitted_forward; @@ -2535,7 +2535,7 @@ ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, have already been emitted. (This type itself may also have been emitted.) If the ARG is 1, this is a CU-mapped deduplication round mapping many - ctf_file_t's into precisely one: conflicting types should be marked + ctf_dict_t's into precisely one: conflicting types should be marked non-root-visible. If the ARG is 0, conflicting types go into per-CU dictionaries stored in the input's ctf_dedup.cd_output: otherwise, everything is emitted directly into the output. No struct/union members are emitted. @@ -2546,16 +2546,16 @@ ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, data object section, backtrace section etc). */ static int -ctf_dedup_emit_type (const char *hval, ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_emit_type (const char *hval, ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, ctf_id_t type, void *id, int depth, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, void *arg) { ctf_dedup_t *d = &output->ctf_dedup; int kind = ctf_type_kind_unsliced (input, type); const char *name; - ctf_file_t *target = output; - ctf_file_t *real_input; + ctf_dict_t *target = output; + ctf_dict_t *real_input; const ctf_type_t *tp; int input_num = CTF_DEDUP_GID_TO_INPUT (id); int output_num = (uint32_t) -1; /* 'shared' */ @@ -2896,14 +2896,14 @@ ctf_dedup_emit_type (const char *hval, ctf_file_t *output, ctf_file_t **inputs, point. */ static int -ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_emit_struct_members (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents) { ctf_dedup_t *d = &output->ctf_dedup; ctf_next_t *i = NULL; void *input_id, *target_id; int err; - ctf_file_t *err_fp, *input_fp; + ctf_dict_t *err_fp, *input_fp; int input_num; ctf_id_t err_type; @@ -2911,7 +2911,7 @@ ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, &input_id, &target_id)) == 0) { ctf_next_t *j = NULL; - ctf_file_t *target; + ctf_dict_t *target; uint32_t target_num; ctf_id_t input_type, target_type; ssize_t offset; @@ -2992,11 +2992,11 @@ ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, dict containing a non-null cd_output resulting from a ctf_dedup_emit_type walk). */ static int -ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, - ctf_file_t **inputs) +ctf_dedup_populate_type_mapping (ctf_dict_t *shared, ctf_dict_t *fp, + ctf_dict_t **inputs) { ctf_dedup_t *d = &shared->ctf_dedup; - ctf_file_t *output = fp->ctf_dedup.cd_output; + ctf_dict_t *output = fp->ctf_dedup.cd_output; const void *k, *v; ctf_next_t *i = NULL; int err; @@ -3029,7 +3029,7 @@ ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, while ((err = ctf_dynset_cnext (type_ids, &j, &id)) == 0) { - ctf_file_t *input = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; + ctf_dict_t *input = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; ctf_id_t id_in = CTF_DEDUP_GID_TO_TYPE (id); #ifdef ENABLE_LIBCTF_HASH_DEBUGGING @@ -3057,7 +3057,7 @@ ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, /* Populate the type mapping machinery used by the rest of the linker, by ctf_add_type, etc. */ static int -ctf_dedup_populate_type_mappings (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_populate_type_mappings (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs) { size_t i; @@ -3094,13 +3094,13 @@ ctf_dedup_populate_type_mappings (ctf_file_t *output, ctf_file_t **inputs, If CU_MAPPED is set, this is a first pass for a link with a non-empty CU mapping: only one output will result. */ -ctf_file_t ** -ctf_dedup_emit (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, +ctf_dict_t ** +ctf_dedup_emit (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, uint32_t *noutputs, int cu_mapped) { size_t num_outputs = 1; /* Always at least one output: us. */ - ctf_file_t **outputs; - ctf_file_t **walk; + ctf_dict_t **outputs; + ctf_dict_t **walk; size_t i; ctf_dprintf ("Triggering emission.\n"); @@ -3124,7 +3124,7 @@ ctf_dedup_emit (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, if (!ctf_assert (output, !cu_mapped || (cu_mapped && num_outputs == 1))) return NULL; - if ((outputs = calloc (num_outputs, sizeof (ctf_file_t *))) == NULL) + if ((outputs = calloc (num_outputs, sizeof (ctf_dict_t *))) == NULL) { ctf_err_warn (output, 0, ENOMEM, _("out of memory allocating link outputs array")); -- cgit v1.1