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, 90 insertions, 89 deletions

diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index ecd0ef2..3f4cfac 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -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. */