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_parent) src_fp = src_fp->ctf_parent; @@ -83,10 +83,10 @@ ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, /* Look up a type mapping: return 0 if none. The DST_FP is modified to point to the parent if need be. The ID returned is from the dst_fp's perspective. */ ctf_id_t -ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, ctf_file_t **dst_fp) +ctf_type_mapping (ctf_dict_t *src_fp, ctf_id_t src_type, ctf_dict_t **dst_fp) { ctf_link_type_key_t key; - ctf_file_t *target_fp = *dst_fp; + ctf_dict_t *target_fp = *dst_fp; ctf_id_t dst_type = 0; if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent) @@ -145,7 +145,7 @@ ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, ctf_file_t **dst_fp) to, or a non-null string otherwise: prefer the parent. Used in debugging output. Sometimes used for outputs too. */ const char * -ctf_link_input_name (ctf_file_t *fp) +ctf_link_input_name (ctf_dict_t *fp) { if (fp->ctf_parent && fp->ctf_parent->ctf_cuname) return fp->ctf_parent->ctf_cuname; @@ -157,15 +157,15 @@ ctf_link_input_name (ctf_file_t *fp) /* The linker inputs look like this. clin_fp is used for short-circuited CU-mapped links that can entirely avoid the first link phase in some - situations in favour of just passing on the contained ctf_file_t: it is - always the sole ctf_file_t inside the corresponding clin_arc. If set, it + situations in favour of just passing on the contained ctf_dict_t: it is + always the sole ctf_dict_t inside the corresponding clin_arc. If set, it gets assigned directly to the final link inputs and freed from there, so it never gets explicitly freed in the ctf_link_input. */ typedef struct ctf_link_input { const char *clin_filename; ctf_archive_t *clin_arc; - ctf_file_t *clin_fp; + ctf_dict_t *clin_fp; int n; } ctf_link_input_t; @@ -181,8 +181,8 @@ ctf_link_input_close (void *input) /* Like ctf_link_add_ctf, below, but with no error-checking, so it can be called in the middle of an ongoing link. */ static int -ctf_link_add_ctf_internal (ctf_file_t *fp, ctf_archive_t *ctf, - ctf_file_t *fp_input, const char *name) +ctf_link_add_ctf_internal (ctf_dict_t *fp, ctf_archive_t *ctf, + ctf_dict_t *fp_input, const char *name) { ctf_link_input_t *input = NULL; char *dupname = NULL; @@ -228,7 +228,7 @@ ctf_link_add_ctf_internal (ctf_file_t *fp, ctf_archive_t *ctf, implemented. */ static int -ctf_link_add (ctf_file_t *fp, ctf_archive_t *ctf, const char *name, +ctf_link_add (ctf_dict_t *fp, ctf_archive_t *ctf, const char *name, void *buf _libctf_unused_, size_t n _libctf_unused_) { if (buf) @@ -275,7 +275,7 @@ ctf_link_add (ctf_file_t *fp, ctf_archive_t *ctf, const char *name, final link output, but otherwise is not important. */ int -ctf_link_add_ctf (ctf_file_t *fp, ctf_archive_t *ctf, const char *name) +ctf_link_add_ctf (ctf_dict_t *fp, ctf_archive_t *ctf, const char *name) { return ctf_link_add (fp, ctf, name, NULL, 0); } @@ -283,10 +283,10 @@ ctf_link_add_ctf (ctf_file_t *fp, ctf_archive_t *ctf, const char *name) /* Return a per-CU output CTF dictionary suitable for the given CU, creating and interning it if need be. */ -static ctf_file_t * -ctf_create_per_cu (ctf_file_t *fp, const char *filename, const char *cuname) +static ctf_dict_t * +ctf_create_per_cu (ctf_dict_t *fp, const char *filename, const char *cuname) { - ctf_file_t *cu_fp; + ctf_dict_t *cu_fp; const char *ctf_name = NULL; char *dynname = NULL; @@ -334,21 +334,21 @@ ctf_create_per_cu (ctf_file_t *fp, const char *filename, const char *cuname) oom: free (dynname); - ctf_file_close (cu_fp); + ctf_dict_close (cu_fp); ctf_set_errno (fp, ENOMEM); return NULL; } /* Add a mapping directing that the CU named FROM should have its - conflicting/non-duplicate types (depending on link mode) go into a container + conflicting/non-duplicate types (depending on link mode) go into a dict named TO. Many FROMs can share a TO. - We forcibly add a container named TO in every case, even though it may well + We forcibly add a dict named TO in every case, even though it may well wind up empty, because clients that use this facility usually expect to find - every TO container present, even if empty, and malfunction otherwise. */ + every TO dict present, even if empty, and malfunction otherwise. */ int -ctf_link_add_cu_mapping (ctf_file_t *fp, const char *from, const char *to) +ctf_link_add_cu_mapping (ctf_dict_t *fp, const char *from, const char *to) { int err; char *f = NULL, *t = NULL; @@ -431,7 +431,7 @@ ctf_link_add_cu_mapping (ctf_file_t *fp, const char *from, const char *to) The changer function accepts a name and should return a new dynamically-allocated name, or NULL if the name should be left unchanged. */ void -ctf_link_set_memb_name_changer (ctf_file_t *fp, +ctf_link_set_memb_name_changer (ctf_dict_t *fp, ctf_link_memb_name_changer_f *changer, void *arg) { @@ -442,12 +442,12 @@ ctf_link_set_memb_name_changer (ctf_file_t *fp, typedef struct ctf_link_in_member_cb_arg { /* The shared output dictionary. */ - ctf_file_t *out_fp; + ctf_dict_t *out_fp; /* The filename of the input file, and an fp to each dictionary in that file in turn. */ const char *in_file_name; - ctf_file_t *in_fp; + ctf_dict_t *in_fp; /* The CU name of the dict being processed. */ const char *cu_name; @@ -456,7 +456,7 @@ typedef struct ctf_link_in_member_cb_arg /* The parent dictionary in the input, and whether it's been processed yet. Not needed by ctf_link_one_type / ctf_link_one_variable, only by higher layers. */ - ctf_file_t *in_fp_parent; + ctf_dict_t *in_fp_parent; int done_parent; /* If true, this is the CU-mapped portion of a deduplicating link: no child @@ -472,7 +472,7 @@ static int ctf_link_one_type (ctf_id_t type, int isroot _libctf_unused_, void *arg_) { ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; - ctf_file_t *per_cu_out_fp; + ctf_dict_t *per_cu_out_fp; int err; if (arg->in_fp->ctf_link_flags != CTF_LINK_SHARE_UNCONFLICTED) @@ -533,7 +533,7 @@ ctf_link_one_type (ctf_id_t type, int isroot _libctf_unused_, void *arg_) /* Set a function which is used to filter out unwanted variables from the link. */ int -ctf_link_set_variable_filter (ctf_file_t *fp, ctf_link_variable_filter_f *filter, +ctf_link_set_variable_filter (ctf_dict_t *fp, ctf_link_variable_filter_f *filter, void *arg) { fp->ctf_link_variable_filter = filter; @@ -541,10 +541,10 @@ ctf_link_set_variable_filter (ctf_file_t *fp, ctf_link_variable_filter_f *filter return 0; } -/* Check if we can safely add a variable with the given type to this container. */ +/* Check if we can safely add a variable with the given type to this dict. */ static int -check_variable (const char *name, ctf_file_t *fp, ctf_id_t type, +check_variable (const char *name, ctf_dict_t *fp, ctf_id_t type, ctf_dvdef_t **out_dvd) { ctf_dvdef_t *dvd; @@ -572,9 +572,9 @@ static int ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_) { ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; - ctf_file_t *per_cu_out_fp; + ctf_dict_t *per_cu_out_fp; ctf_id_t dst_type = 0; - ctf_file_t *check_fp; + ctf_dict_t *check_fp; ctf_dvdef_t *dvd; /* See if this variable is filtered out. */ @@ -587,7 +587,7 @@ ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_) } /* In unconflicted link mode, if this type is mapped to a type in the parent - container, we want to try to add to that first: if it reports a duplicate, + dict, we want to try to add to that first: if it reports a duplicate, or if the type is in a child already, add straight to the child. */ check_fp = arg->out_fp; @@ -657,7 +657,7 @@ ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_) ambiguous types if there is one and it's not the default: otherwise, we use the name of the input file. */ static int -ctf_link_one_input_archive_member (ctf_file_t *in_fp, const char *name, void *arg_) +ctf_link_one_input_archive_member (ctf_dict_t *in_fp, const char *name, void *arg_) { ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; int err = 0; @@ -705,7 +705,7 @@ static void empty_link_type_mapping (void *key _libctf_unused_, void *value, void *arg _libctf_unused_) { - ctf_file_t *fp = (ctf_file_t *) value; + ctf_dict_t *fp = (ctf_dict_t *) value; if (fp->ctf_link_type_mapping) ctf_dynhash_empty (fp->ctf_link_type_mapping); @@ -716,7 +716,7 @@ empty_link_type_mapping (void *key _libctf_unused_, void *value, Returns the number of files contained within the opened archive (0 for none), or -1 on error, as usual. */ static ssize_t -ctf_link_lazy_open (ctf_file_t *fp, ctf_link_input_t *input) +ctf_link_lazy_open (ctf_dict_t *fp, ctf_link_input_t *input) { size_t count; int err; @@ -803,7 +803,7 @@ ctf_link_one_input_archive (void *key, void *value, void *arg_) if (ctf_link_one_input_archive_member (arg->in_fp_parent, _CTF_SECTION, arg) < 0) { - ctf_file_close (arg->in_fp_parent); + ctf_dict_close (arg->in_fp_parent); goto out; } arg->done_parent = 1; @@ -818,7 +818,7 @@ ctf_link_one_input_archive (void *key, void *value, void *arg_) is zero if there was no actual error from the caller. */ ctf_set_errno (arg->out_fp, 0); } - ctf_file_close (arg->in_fp_parent); + ctf_dict_close (arg->in_fp_parent); out: ctf_link_close_one_input_archive (key, value, NULL); @@ -827,7 +827,7 @@ ctf_link_one_input_archive (void *key, void *value, void *arg_) typedef struct link_sort_inputs_cb_arg { int is_cu_mapped; - ctf_file_t *fp; + ctf_dict_t *fp; } link_sort_inputs_cb_arg_t; /* Sort the inputs by N (the link order). For CU-mapped links, this is a @@ -875,7 +875,7 @@ ctf_link_sort_inputs (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two, and optionally the name and ctf_link_input_t of the single input archive if only one exists (no matter how many dicts it contains). */ static ssize_t -ctf_link_deduplicating_count_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, +ctf_link_deduplicating_count_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names, ctf_link_input_t **only_one_input) { ctf_dynhash_t *inputs = fp->ctf_link_inputs; @@ -952,23 +952,23 @@ ctf_link_deduplicating_count_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, If no inputs exist that correspond to these CUs, return NULL with the errno set to ECTF_NOCTFDATA. */ -static ctf_file_t ** -ctf_link_deduplicating_open_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, +static ctf_dict_t ** +ctf_link_deduplicating_open_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names, ssize_t ninputs, uint32_t **parents) { ctf_dynhash_t *inputs = fp->ctf_link_inputs; ctf_next_t *i = NULL; void *name, *input; link_sort_inputs_cb_arg_t sort_arg; - ctf_file_t **dedup_inputs = NULL; - ctf_file_t **walk; + ctf_dict_t **dedup_inputs = NULL; + ctf_dict_t **walk; uint32_t *parents_ = NULL; int err; if (cu_names) inputs = cu_names; - if ((dedup_inputs = calloc (ninputs, sizeof (ctf_file_t *))) == NULL) + if ((dedup_inputs = calloc (ninputs, sizeof (ctf_dict_t *))) == NULL) goto oom; if ((parents_ = calloc (ninputs, sizeof (uint32_t))) == NULL) @@ -987,8 +987,8 @@ ctf_link_deduplicating_open_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, { const char *one_name = (const char *) name; ctf_link_input_t *one_input; - ctf_file_t *one_fp; - ctf_file_t *parent_fp = NULL; + ctf_dict_t *one_fp; + ctf_dict_t *parent_fp = NULL; uint32_t parent_i; ctf_next_t *j = NULL; @@ -1088,8 +1088,8 @@ ctf_link_deduplicating_open_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, CU_NAMES. If CU_NAMES is not specified, close all the ctf_link_inputs in one go, leaving it empty. */ static int -ctf_link_deduplicating_close_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, - ctf_file_t **inputs, ssize_t ninputs) +ctf_link_deduplicating_close_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names, + ctf_dict_t **inputs, ssize_t ninputs) { ctf_next_t *it = NULL; void *name; @@ -1099,7 +1099,7 @@ ctf_link_deduplicating_close_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, /* This is the inverse of ctf_link_deduplicating_open_inputs: so first, close all the individual input dicts, opened by the archive iterator. */ for (i = 0; i < ninputs; i++) - ctf_file_close (inputs[i]); + ctf_dict_close (inputs[i]); /* Now close the archives they are part of. */ if (cu_names) @@ -1126,7 +1126,7 @@ ctf_link_deduplicating_close_inputs (ctf_file_t *fp, ctf_dynhash_t *cu_names, /* Do a deduplicating link of all variables in the inputs. */ static int -ctf_link_deduplicating_variables (ctf_file_t *fp, ctf_file_t **inputs, +ctf_link_deduplicating_variables (ctf_dict_t *fp, ctf_dict_t **inputs, size_t ninputs, int cu_mapped) { ctf_link_in_member_cb_arg_t arg; @@ -1155,7 +1155,7 @@ ctf_link_deduplicating_variables (ctf_file_t *fp, ctf_file_t **inputs, /* Do the per-CU part of a deduplicating link. */ static int -ctf_link_deduplicating_per_cu (ctf_file_t *fp) +ctf_link_deduplicating_per_cu (ctf_dict_t *fp) { ctf_next_t *i = NULL; int err; @@ -1172,9 +1172,9 @@ ctf_link_deduplicating_per_cu (ctf_file_t *fp) { const char *out_name = (const char *) out_cu; ctf_dynhash_t *in = (ctf_dynhash_t *) in_cus; - ctf_file_t *out = NULL; - ctf_file_t **inputs; - ctf_file_t **outputs; + ctf_dict_t *out = NULL; + ctf_dict_t **inputs; + ctf_dict_t **outputs; ctf_archive_t *in_arc; ssize_t ninputs; ctf_link_input_t *only_input; @@ -1336,17 +1336,17 @@ ctf_link_deduplicating_per_cu (ctf_file_t *fp) goto err_outputs; } - ctf_file_close (out); + ctf_dict_close (out); free (outputs); continue; err_inputs_outputs: ctf_list_splice (&fp->ctf_errs_warnings, &outputs[0]->ctf_errs_warnings); - ctf_file_close (outputs[0]); + ctf_dict_close (outputs[0]); free (outputs); err_inputs: ctf_link_deduplicating_close_inputs (fp, in, inputs, ninputs); - ctf_file_close (out); + ctf_dict_close (out); free (inputs); free (parents); err_open_inputs: @@ -1355,7 +1355,7 @@ ctf_link_deduplicating_per_cu (ctf_file_t *fp) err_outputs: ctf_list_splice (&fp->ctf_errs_warnings, &outputs[0]->ctf_errs_warnings); - ctf_file_close (outputs[0]); + ctf_dict_close (outputs[0]); free (outputs); ctf_next_destroy (i); return -1; /* Errno is set for us. */ @@ -1372,10 +1372,10 @@ ctf_link_deduplicating_per_cu (ctf_file_t *fp) /* Do a deduplicating link using the ctf-dedup machinery. */ static void -ctf_link_deduplicating (ctf_file_t *fp) +ctf_link_deduplicating (ctf_dict_t *fp) { size_t i; - ctf_file_t **inputs, **outputs = NULL; + ctf_dict_t **inputs, **outputs = NULL; ssize_t ninputs; uint32_t noutputs; uint32_t *parents; @@ -1425,7 +1425,7 @@ ctf_link_deduplicating (ctf_file_t *fp) /* We already have access to this one. Close the duplicate. */ if (i == 0) { - ctf_file_close (outputs[0]); + ctf_dict_close (outputs[0]); continue; } @@ -1443,7 +1443,7 @@ ctf_link_deduplicating (ctf_file_t *fp) free (dynname); for (; i < noutputs; i++) - ctf_file_close (outputs[i]); + ctf_dict_close (outputs[i]); goto err; } @@ -1453,7 +1453,7 @@ ctf_link_deduplicating (ctf_file_t *fp) ctf_err_warn (fp, 0, 0, _("deduplicating link variable emission failed for " "%s"), ctf_link_input_name (fp)); for (i = 1; i < noutputs; i++) - ctf_file_close (outputs[i]); + ctf_dict_close (outputs[i]); goto err; } @@ -1469,7 +1469,7 @@ ctf_link_deduplicating (ctf_file_t *fp) err: for (i = 0; i < (size_t) ninputs; i++) - ctf_file_close (inputs[i]); + ctf_dict_close (inputs[i]); free (inputs); free (parents); free (outputs); @@ -1479,7 +1479,7 @@ ctf_link_deduplicating (ctf_file_t *fp) /* Merge types and variable sections in all files added to the link together. All the added files are closed. */ int -ctf_link (ctf_file_t *fp, int flags) +ctf_link (ctf_dict_t *fp, int flags) { ctf_link_in_member_cb_arg_t arg; ctf_next_t *i = NULL; @@ -1496,7 +1496,7 @@ ctf_link (ctf_file_t *fp, int flags) fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string, free, (ctf_hash_free_fun) - ctf_file_close); + ctf_dict_close); if (fp->ctf_link_outputs == NULL) return ctf_set_errno (fp, ENOMEM); @@ -1555,7 +1555,7 @@ static void ctf_link_intern_extern_string (void *key _libctf_unused_, void *value, void *arg_) { - ctf_file_t *fp = (ctf_file_t *) value; + ctf_dict_t *fp = (ctf_dict_t *) value; ctf_link_out_string_cb_arg_t *arg = (ctf_link_out_string_cb_arg_t *) arg_; fp->ctf_flags |= LCTF_DIRTY; @@ -1570,7 +1570,7 @@ ctf_link_intern_extern_string (void *key _libctf_unused_, void *value, files ctf_link() can create to get their strings dedupped against the ELF strtab properly. */ int -ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string, +ctf_link_add_strtab (ctf_dict_t *fp, ctf_link_strtab_string_f *add_string, void *arg) { const char *str; @@ -1596,7 +1596,7 @@ ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string, /* Not yet implemented. */ int -ctf_link_shuffle_syms (ctf_file_t *fp _libctf_unused_, +ctf_link_shuffle_syms (ctf_dict_t *fp _libctf_unused_, ctf_link_iter_symbol_f *add_sym _libctf_unused_, void *arg _libctf_unused_) { @@ -1606,8 +1606,8 @@ ctf_link_shuffle_syms (ctf_file_t *fp _libctf_unused_, typedef struct ctf_name_list_accum_cb_arg { char **names; - ctf_file_t *fp; - ctf_file_t **files; + ctf_dict_t *fp; + ctf_dict_t **files; size_t i; char **dynames; size_t ndynames; @@ -1618,9 +1618,9 @@ static void ctf_accumulate_archive_names (void *key, void *value, void *arg_) { const char *name = (const char *) key; - ctf_file_t *fp = (ctf_file_t *) value; + ctf_dict_t *fp = (ctf_dict_t *) value; char **names; - ctf_file_t **files; + ctf_dict_t **files; ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_; if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL) @@ -1630,7 +1630,7 @@ ctf_accumulate_archive_names (void *key, void *value, void *arg_) return; } - if ((files = realloc (arg->files, sizeof (ctf_file_t *) * arg->i)) == NULL) + if ((files = realloc (arg->files, sizeof (ctf_dict_t *) * arg->i)) == NULL) { (arg->i)--; ctf_set_errno (arg->fp, ENOMEM); @@ -1675,7 +1675,7 @@ ctf_accumulate_archive_names (void *key, void *value, void *arg_) static void ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg) { - ctf_file_t *fp = (ctf_file_t *) value; + ctf_dict_t *fp = (ctf_dict_t *) value; const char *name = (const char *) arg; ctf_parent_name_set (fp, name); @@ -1685,12 +1685,12 @@ ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg) (otherwise) into a new dynamically-allocated string, and return it. Members with sizes above THRESHOLD are compressed. */ unsigned char * -ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold) +ctf_link_write (ctf_dict_t *fp, size_t *size, size_t threshold) { ctf_name_list_accum_cb_arg_t arg; char **names; char *transformed_name = NULL; - ctf_file_t **files; + ctf_dict_t **files; FILE *f = NULL; int err; long fsize; @@ -1710,7 +1710,7 @@ ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold) } } - /* No extra outputs? Just write a simple ctf_file_t. */ + /* No extra outputs? Just write a simple ctf_dict_t. */ if (arg.i == 0) return ctf_write_mem (fp, size, threshold); @@ -1741,13 +1741,13 @@ ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold) } if ((files = realloc (arg.files, - sizeof (struct ctf_file *) * (arg.i + 1))) == NULL) + sizeof (struct ctf_dict *) * (arg.i + 1))) == NULL) { - errloc = "ctf_file reallocation"; + errloc = "ctf_dict reallocation"; goto err_no; } arg.files = files; - memmove (&(arg.files[1]), arg.files, sizeof (ctf_file_t *) * (arg.i)); + memmove (&(arg.files[1]), arg.files, sizeof (ctf_dict_t *) * (arg.i)); arg.files[0] = fp; if ((f = tmpfile ()) == NULL) -- cgit v1.1