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.

1 files changed, 13 insertions, 13 deletions

diff --git a/libctf/ctf-lookup.c b/libctf/ctf-lookup.c
index 57fb6c5..5682bf0 100644
--- a/libctf/ctf-lookup.c
+++ b/libctf/ctf-lookup.c
@@ -69,7 +69,7 @@ isqualifier (const char *s, size_t len)
    integers, floats, typedefs, and pointers to any of these named types.  */
 
 ctf_id_t
-ctf_lookup_by_name (ctf_file_t *fp, const char *name)
+ctf_lookup_by_name (ctf_dict_t *fp, const char *name)
 {
   static const char delimiters[] = " \t\n\r\v\f*";
 
@@ -102,7 +102,7 @@ ctf_lookup_by_name (ctf_file_t *fp, const char *name)
 	     data includes "struct foo *" but not "foo_t *" and
 	     the user tries to access "foo_t *" in the debugger.
 
-	     TODO need to handle parent containers too.  */
+	     TODO need to handle parent dicts too.  */
 
 	  ntype = fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, type)];
 	  if (ntype == 0)
@@ -194,7 +194,7 @@ err:
 
 typedef struct ctf_lookup_var_key
 {
-  ctf_file_t *clvk_fp;
+  ctf_dict_t *clvk_fp;
   const char *clvk_name;
 } ctf_lookup_var_key_t;
 
@@ -212,7 +212,7 @@ ctf_lookup_var (const void *key_, const void *memb_)
 /* Given a variable name, return the type of the variable with that name.  */
 
 ctf_id_t
-ctf_lookup_variable (ctf_file_t *fp, const char *name)
+ctf_lookup_variable (ctf_dict_t *fp, const char *name)
 {
   ctf_varent_t *ent;
   ctf_lookup_var_key_t key = { fp, name };
@@ -236,7 +236,7 @@ ctf_lookup_variable (ctf_file_t *fp, const char *name)
 /* Given a symbol table index, return the name of that symbol from the secondary
    string table, or the null string (never NULL).  */
 const char *
-ctf_lookup_symbol_name (ctf_file_t *fp, unsigned long symidx)
+ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
 {
   const ctf_sect_t *sp = &fp->ctf_symtab;
   Elf64_Sym sym, *gsp;
@@ -271,7 +271,7 @@ ctf_lookup_symbol_name (ctf_file_t *fp, unsigned long symidx)
    by the corresponding entry in the symbol table.  */
 
 ctf_id_t
-ctf_lookup_by_symbol (ctf_file_t *fp, unsigned long symidx)
+ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
 {
   const ctf_sect_t *sp = &fp->ctf_symtab;
   ctf_id_t type;
@@ -308,8 +308,8 @@ ctf_lookup_by_symbol (ctf_file_t *fp, unsigned long symidx)
 /* Return the native dict of a given type: if called on a child and the
    type is in the parent, return the parent.  Needed if you plan to access
    the type directly, without using the API.  */
-ctf_file_t *
-ctf_get_dict (ctf_file_t *fp, ctf_id_t type)
+ctf_dict_t *
+ctf_get_dict (ctf_dict_t *fp, ctf_id_t type)
 {
     if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, type))
       return fp->ctf_parent;
@@ -322,9 +322,9 @@ ctf_get_dict (ctf_file_t *fp, ctf_id_t type)
    This function is not exported outside of the library.  */
 
 const ctf_type_t *
-ctf_lookup_by_id (ctf_file_t **fpp, ctf_id_t type)
+ctf_lookup_by_id (ctf_dict_t **fpp, ctf_id_t type)
 {
-  ctf_file_t *fp = *fpp;	/* Caller passes in starting CTF dict.  */
+  ctf_dict_t *fp = *fpp;	/* Caller passes in starting CTF dict.  */
   ctf_id_t idx;
 
   if ((fp = ctf_get_dict (fp, type)) == NULL)
@@ -353,7 +353,7 @@ ctf_lookup_by_id (ctf_file_t **fpp, ctf_id_t type)
   idx = LCTF_TYPE_TO_INDEX (fp, type);
   if (idx > 0 && (unsigned long) idx <= fp->ctf_typemax)
     {
-      *fpp = fp;		/* Function returns ending CTF container.  */
+      *fpp = fp;		/* Function returns ending CTF dict.  */
       return (LCTF_INDEX_TO_TYPEPTR (fp, idx));
     }
 
@@ -365,7 +365,7 @@ ctf_lookup_by_id (ctf_file_t **fpp, ctf_id_t type)
    by the corresponding entry in the symbol table.  */
 
 int
-ctf_func_info (ctf_file_t *fp, unsigned long symidx, ctf_funcinfo_t *fip)
+ctf_func_info (ctf_dict_t *fp, unsigned long symidx, ctf_funcinfo_t *fip)
 {
   const ctf_sect_t *sp = &fp->ctf_symtab;
   const uint32_t *dp;
@@ -422,7 +422,7 @@ ctf_func_info (ctf_file_t *fp, unsigned long symidx, ctf_funcinfo_t *fip)
    by the corresponding entry in the symbol table.  */
 
 int
-ctf_func_args (ctf_file_t * fp, unsigned long symidx, uint32_t argc,
+ctf_func_args (ctf_dict_t *fp, unsigned long symidx, uint32_t argc,
 	       ctf_id_t * argv)
 {
   const uint32_t *dp;