[v4,29/35] libctf: avoid the need to ever use ctf_update

Message ID 20190924135131.441906-30-nick.alcock@oracle.com
State New
Headers show
Series
  • CTF linking support
Related show

Commit Message

Nick Alcock Sept. 24, 2019, 1:51 p.m.
The method of operation of libctf when the dictionary is writable has
before now been that types that are added land in the dynamic type
section, which is a linked list and hash of IDs -> dynamic type
definitions (and, recently a hash of names): the DTDs are a bit of CTF
representing the ctf_type_t and ad hoc C structures representing the
vlen.  Historically, libctf was unable to do anything with these types,
not even look them up by ID, let alone by name: if you wanted to do that
say if you were adding a type that depended on one you just added) you
called ctf_update, which serializes all the DTDs into a CTF file and
reopens it, copying its guts over the fp it's called with.  The
ctf_updated types are then frozen in amber and unchangeable: all lookups
will return the types in the static portion in preference to the dynamic
portion, and we will refuse to re-add things that already exist in the
static portion (and, of late, in the dynamic portion too).  The libctf
machinery remembers the boundary between static and dynamic types and
looks in the right portion for each type.  Lots of things still don't
quite work with dynamic types (e.g. getting their size), but enough
works to do a bunch of additions and then a ctf_update, most of the
time.

Except it doesn't, because ctf_add_type finds it necessary to walk the
full dynamic type definition list looking for types with matching names,
so it gets slower and slower with every type you add: fixing this
requires calling ctf_update periodically for no other reason than to
avoid massively slowing things down.

This is all clunky and very slow but kind of works, until you consider
that it is in fact possible and indeed necessary to modify one sort of
type after it has been added: forwards.  These are necessarily promoted
to structs, unions or enums, and when they do so *their type ID does not
change*.  So all of a sudden we are changing types that already exist in
the static portion.  ctf_update gets massively confused by this and
allocates space enough for the forward (with no members), but then emits
the new dynamic type (with all the members) into it.  You get an
assertion failure after that, if you're lucky, or a coredump.

So this commit rejigs things a bit and arranges to exclusively use the
dynamic type definitions in writable dictionaries, and the static type
definitions in readable dictionaries: we don't at any time have a mixture
of static and dynamic types, and you don't need to call ctf_update to
make things "appear".  The ctf_dtbyname hash I introduced a few months
ago, which maps things like "struct foo" to DTDs, is removed, replaced
instead by a change of type of the four dictionaries which track names.
Rather than just being (unresizable) ctf_hash_t's populated only at
ctf_bufopen time, they are now a ctf_names_t structure, which is a pair
of ctf_hash_t and ctf_dynhash_t, with the ctf_hash_t portion being used
in readonly dictionaries, and the ctf_dynhash_t being used in writable
ones.  The decision as to which to use is centralized in the new
functions ctf_lookup_by_rawname (which takes a type kind) and
ctf_lookup_by_rawhash, which it calls (which takes a ctf_names_t *.)

This change lets us switch from using static to dynamic name hashes on
the fly across the entirety of libctf without complexifying anything: in
fact, because we now centralize the knowledge about how to map from type
kind to name hash, it actually simplifies things and lets us throw out
quite a lot of now-unnecessary complexity, from ctf_dtnyname (replaced
by the dynamic half of the name tables), through to ctf_dtnextid (now
that a dictionary's static portion is never referenced if the dictionary
is writable, we can just use ctf_typemax to indicate the maximum type:
dynamic or non-dynamic does not matter, and we no longer need to track
the boundary between the types).  You can now ctf_rollback() as far as
you like, even past a ctf_update or for that matter a full writeout; all
the iteration functions work just as well on writable as on read-only
dictionaries; ctf_add_type no longer needs expensive duplicated code to
run over the dynamic types hunting for ones it might be interested in;
and the linker no longer needs a hack to call ctf_update so that calling
ctf_add_type is not impossibly expensive.

There is still a bit more complexity: some new code paths in ctf-types.c
need to know how to extract information from dynamic types.  This
complexity will go away again in a few months when libctf acquires a
proper intermediate representation.

You can still call ctf_update if you like (it's public API, after all),
but its only effect now is to set the point to which ctf_discard rolls
back.

Obviously *something* still needs to serialize the CTF file before
writeout, and this job is done by ctf_serialize, which does everything
ctf_update used to except set the counter used by ctf_discard.  It is
automatically called by the various functions that do CTF writeout:
nobody else ever needs to call it.

With this in place, forwards that are promoted to non-forwards no longer
crash the link, even if it happens tens of thousands of types later.

libctf/
	* ctf-impl.h (ctf_names_t): New.
	(ctf_lookup_t) <ctf_hash>: Now a ctf_names_t, not a ctf_hash_t.
	(ctf_file_t) <ctf_structs>: Likewise.
	<ctf_unions>: Likewise.
	<ctf_enums>: Likewise.
	<ctf_names>: Likewise.
	<ctf_lookups>: Improve comment.
	<ctf_ptrtab_len>: New.
	<ctf_prov_strtab>: New.
	<ctf_str_prov_offset>: New.
	<ctf_dtbyname>: Remove, redundant to the names hashes.
	<ctf_dtnextid>: Remove, redundant to ctf_typemax.
	(ctf_dtdef_t) <dtd_name>: Remove.
	<dtd_data>: Note that the ctt_name is now populated.
	(ctf_str_atom_t) <csa_offset>: This is now the strtab
	offset for internal strings too.
	<csa_external_offset>: New, the external strtab offset.
	(CTF_INDEX_TO_TYPEPTR): Handle the LCTF_RDWR case.
	(ctf_name_table): New declaration.
	(ctf_lookup_by_rawname): Likewise.
	(ctf_lookup_by_rawhash): Likewise.
	(ctf_set_ctl_hashes): Likewise.
	(ctf_serialize): Likewise.
	(ctf_dtd_insert): Adjust.
	(ctf_simple_open_internal): Likewise.
	(ctf_bufopen_internal): Likewise.
	(ctf_list_empty_p): Likewise.
	(ctf_str_remove_ref): Likewise.
	(ctf_str_add): Returns uint32_t now.
	(ctf_str_add_ref): Likewise.
	(ctf_str_add_external): Now returns a boolean (int).
	* ctf-string.c (ctf_strraw_explicit): Check the ctf_prov_strtab
	for strings in the appropriate range.
	(ctf_str_create_atoms): Create the ctf_prov_strtab.  Detect OOM
	when adding the null string to the new strtab.
	(ctf_str_free_atoms): Destroy the ctf_prov_strtab.
	(ctf_str_add_ref_internal): Add make_provisional argument.  If
	make_provisional, populate the offset and fill in the
	ctf_prov_strtab accordingly.
	(ctf_str_add): Return the offset, not the string.
	(ctf_str_add_ref): Likewise.
	(ctf_str_add_external): Return a success integer.
	(ctf_str_remove_ref): New, remove a single ref.
	(ctf_str_count_strtab): Do not count the initial null string's
	length or the existence or length of any unreferenced internal
	atoms.
	(ctf_str_populate_sorttab): Skip atoms with no refs.
	(ctf_str_write_strtab): Populate the nullstr earlier.  Add one
	to the cts_len for the null string, since it is no longer done
	in ctf_str_count_strtab.  Adjust for csa_external_offset rename.
	Populate the csa_offset for both internal and external cases.
	Flush the ctf_prov_strtab afterwards, and reset the
	ctf_str_prov_offset.
	* ctf-create.c (ctf_grow_ptrtab): New.
	(ctf_create): Call it.	Initialize new fields rather than old
	ones.  Tell ctf_bufopen_internal that this is a writable dictionary.
	Set the ctl hashes and data model.
	(ctf_update): Rename to...
	(ctf_serialize): ... this.  Leave a compatibility function behind.
	Tell ctf_simple_open_internal that this is a writable dictionary.
	Pass the new fields along from the old dictionary.  Drop
	ctf_dtnextid and ctf_dtbyname.	Use ctf_strraw, not dtd_name.
	Do not zero out the DTD's ctt_name.
	(ctf_prefixed_name): Rename to...
	(ctf_name_table): ... this.  No longer return a prefixed name: return
	the applicable name table instead.
	(ctf_dtd_insert): Use it, and use the right name table.	 Pass in the
	kind we're adding.  Migrate away from dtd_name.
	(ctf_dtd_delete): Adjust similarly.  Remove the ref to the
	deleted ctt_name.
	(ctf_dtd_lookup_type_by_name): Remove.
	(ctf_dynamic_type): Always return NULL on read-only dictionaries.
	No longer check ctf_dtnextid: check ctf_typemax instead.
	(ctf_snapshot): No longer use ctf_dtnextid: use ctf_typemax instead.
	(ctf_rollback): Likewise.  No longer fail with ECTF_OVERROLLBACK. Use
	ctf_name_table and the right name table, and migrate away from
	dtd_name as in ctf_dtd_delete.
	(ctf_add_generic): Pass in the kind explicitly and pass it to
	ctf_dtd_insert. Use ctf_typemax, not ctf_dtnextid.  Migrate away
	from dtd_name to using ctf_str_add_ref to populate the ctt_name.
        Grow the ptrtab if needed.
	(ctf_add_encoded): Pass in the kind.
	(ctf_add_slice): Likewise.
	(ctf_add_array): Likewise.
	(ctf_add_function): Likewise.
	(ctf_add_typedef): Likewise.
	(ctf_add_reftype): Likewise. Initialize the ctf_ptrtab, checking
	ctt_name rather than dtd_name.
	(ctf_add_struct_sized): Pass in the kind.  Use
	ctf_lookup_by_rawname, not ctf_hash_lookup_type /
	ctf_dtd_lookup_type_by_name.
	(ctf_add_union_sized): Likewise.
	(ctf_add_enum): Likewise.
	(ctf_add_enum_encoded): Likewise.
	(ctf_add_forward): Likewise.
	(ctf_add_type): Likewise.
	(ctf_compress_write): Call ctf_serialize: adjust for ctf_size not
	being initialized until after the call.
	(ctf_write_mem): Likewise.
	(ctf_write): Likewise.
	* ctf-archive.c (arc_write_one_ctf): Likewise.
	* ctf-lookup.c (ctf_lookup_by_name): Use ctf_lookuup_by_rawhash, not
	ctf_hash_lookup_type.
	(ctf_lookup_by_id): No longer check the readonly types if the
	dictionary is writable.
	* ctf-open.c (init_types): Assert that this dictionary is not
	writable.  Adjust to use the new name hashes, ctf_name_table,
	and ctf_ptrtab_len.  GNU style fix for the final ptrtab scan.
	(ctf_bufopen_internal): New 'writable' parameter.  Flip on LCTF_RDWR
	if set.	 Drop out early when dictionary is writable.  Split the
	ctf_lookups initialization into...
	(ctf_set_cth_hashes): ... this new function.
	(ctf_simple_open_internal): Adjust.  New 'writable' parameter.
	(ctf_simple_open): Adjust accordingly.
	(ctf_bufopen): Likewise.
	(ctf_file_close): Destroy the appropriate name hashes.	No longer
	destroy ctf_dtbyname, which is gone.
	(ctf_getdatasect): Remove spurious "extern".
	* ctf-types.c (ctf_lookup_by_rawname): New, look up types in the
	specified name table, given a kind.
	(ctf_lookup_by_rawhash): Likewise, given a ctf_names_t *.
	(ctf_member_iter): Add support for iterating over the
	dynamic type list.
	(ctf_enum_iter): Likewise.
	(ctf_variable_iter): Likewise.
	(ctf_type_rvisit): Likewise.
	(ctf_member_info): Add support for types in the dynamic type list.
	(ctf_enum_name): Likewise.
	(ctf_enum_value): Likewise.
	(ctf_func_type_info): Likewise.
	(ctf_func_type_args): Likewise.
	* ctf-link.c (ctf_accumulate_archive_names): No longer call
	ctf_update.
	(ctf_link_write): Likewise.
	(ctf_link_intern_extern_string): Adjust for new
	ctf_str_add_external return value.
	(ctf_link_add_strtab): Likewise.
	* ctf-util.c (ctf_list_empty_p): New.
---
 libctf/ctf-archive.c |   3 +
 libctf/ctf-create.c  | 425 ++++++++++++++++++++++++-------------------
 libctf/ctf-impl.h    |  54 ++++--
 libctf/ctf-link.c    |  20 +-
 libctf/ctf-lookup.c  |  23 ++-
 libctf/ctf-open.c    | 207 +++++++++++----------
 libctf/ctf-string.c  | 163 +++++++++++++----
 libctf/ctf-types.c   | 277 +++++++++++++++++++++-------
 libctf/ctf-util.c    |   8 +
 9 files changed, 756 insertions(+), 424 deletions(-)

-- 
2.23.0.239.g28aa4420fd

Patch

diff --git a/libctf/ctf-archive.c b/libctf/ctf-archive.c
index 979641cc1e7..ed1483ade75 100644
--- a/libctf/ctf-archive.c
+++ b/libctf/ctf-archive.c
@@ -267,6 +267,9 @@  arc_write_one_ctf (ctf_file_t * f, int fd, size_t threshold)
   size_t ctfsz_len;
   int (*writefn) (ctf_file_t * fp, int fd);
 
+  if (ctf_serialize (f) < 0)
+    return f->ctf_errno * -1;
+
   if ((off = lseek (fd, 0, SEEK_CUR)) < 0)
     return errno * -1;
 
diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 1c397c6d068..aec0cfa8678 100644
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -27,6 +27,40 @@ 
 #define roundup(x, y)  ((((x) + ((y) - 1)) / (y)) * (y))
 #endif
 
+/* Make sure the ptrtab has enough space for at least one more type.
+
+   We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
+   at a time.  */
+
+static int
+ctf_grow_ptrtab (ctf_file_t *fp)
+{
+  size_t new_ptrtab_len = fp->ctf_ptrtab_len;
+
+  /* We allocate one more ptrtab entry than we need, for the initial zero,
+     plus one because the caller will probably allocate a new type.  */
+
+  if (fp->ctf_ptrtab == NULL)
+    new_ptrtab_len = 1024;
+  else if ((fp->ctf_typemax + 2) > fp->ctf_ptrtab_len)
+    new_ptrtab_len = fp->ctf_ptrtab_len * 1.25;
+
+  if (new_ptrtab_len != fp->ctf_ptrtab_len)
+    {
+      uint32_t *new_ptrtab;
+
+      if ((new_ptrtab = realloc (fp->ctf_ptrtab,
+				 new_ptrtab_len * sizeof (uint32_t))) == NULL)
+	return (ctf_set_errno (fp, ENOMEM));
+
+      fp->ctf_ptrtab = new_ptrtab;
+      memset (fp->ctf_ptrtab + fp->ctf_ptrtab_len, 0,
+	      (new_ptrtab_len - fp->ctf_ptrtab_len) * sizeof (uint32_t));
+      fp->ctf_ptrtab_len = new_ptrtab_len;
+    }
+  return 0;
+}
+
 /* To create an empty CTF container, we just declare a zeroed header and call
    ctf_bufopen() on it.  If ctf_bufopen succeeds, we mark the new container r/w
    and initialize the dynamic members.  We start assigning type IDs at 1 because
@@ -39,7 +73,7 @@  ctf_create (int *errp)
 
   ctf_dynhash_t *dthash;
   ctf_dynhash_t *dvhash;
-  ctf_dynhash_t *dtbyname;
+  ctf_dynhash_t *structs = NULL, *unions = NULL, *enums = NULL, *names = NULL;
   ctf_sect_t cts;
   ctf_file_t *fp;
 
@@ -60,9 +94,15 @@  ctf_create (int *errp)
       goto err_dt;
     }
 
-  dtbyname = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
-				 free, NULL);
-  if (dtbyname == NULL)
+  structs = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
+				NULL, NULL);
+  unions = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
+			       NULL, NULL);
+  enums = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
+			      NULL, NULL);
+  names = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
+			      NULL, NULL);
+  if (!structs || !unions || !enums || !names)
     {
       ctf_set_open_errno (errp, EAGAIN);
       goto err_dv;
@@ -73,23 +113,35 @@  ctf_create (int *errp)
   cts.cts_size = sizeof (hdr);
   cts.cts_entsize = 1;
 
-  if ((fp = ctf_bufopen (&cts, NULL, NULL, errp)) == NULL)
-      goto err_dtbyname;
+  if ((fp = ctf_bufopen_internal (&cts, NULL, NULL, NULL, 1, errp)) == NULL)
+    goto err_dv;
 
-  fp->ctf_flags |= LCTF_RDWR;
-  fp->ctf_dtbyname = dtbyname;
+  fp->ctf_structs.ctn_writable = structs;
+  fp->ctf_unions.ctn_writable = unions;
+  fp->ctf_enums.ctn_writable = enums;
+  fp->ctf_names.ctn_writable = names;
   fp->ctf_dthash = dthash;
   fp->ctf_dvhash = dvhash;
-  fp->ctf_dtnextid = 1;
   fp->ctf_dtoldid = 0;
   fp->ctf_snapshots = 1;
   fp->ctf_snapshot_lu = 0;
 
+  ctf_set_ctl_hashes (fp);
+  ctf_setmodel (fp, CTF_MODEL_NATIVE);
+  if (ctf_grow_ptrtab (fp) < 0)
+    {
+      ctf_set_open_errno (errp, ctf_errno (fp));
+      ctf_file_close (fp);
+      return NULL;
+    }
+
   return fp;
 
- err_dtbyname:
-  ctf_dynhash_destroy (dtbyname);
  err_dv:
+  ctf_dynhash_destroy (structs);
+  ctf_dynhash_destroy (unions);
+  ctf_dynhash_destroy (enums);
+  ctf_dynhash_destroy (names);
   ctf_dynhash_destroy (dvhash);
  err_dt:
   ctf_dynhash_destroy (dthash);
@@ -187,22 +239,29 @@  ctf_sort_var (const void *one_, const void *two_, void *arg_)
 		  ctf_strraw_explicit (arg->fp, two->ctv_name, arg->strtab)));
 }
 
-/* If the specified CTF container is writable and has been modified, reload this
-   container with the updated type definitions.  In order to make this code and
-   the rest of libctf as simple as possible, we perform updates by taking the
-   dynamic type definitions and creating an in-memory CTF file containing the
-   definitions, and then call ctf_simple_open_internal() on it.  This not only
-   leverages ctf_simple_open(), but also avoids having to bifurcate the rest of
-   the library code with different lookup paths for static and dynamic type
-   definitions.  We are therefore optimizing greatly for lookup over update,
-   which we assume will be an uncommon operation.  We perform one extra trick
-   here for the benefit of callers and to keep our code simple:
-   ctf_simple_open_internal() will return a new ctf_file_t, but we want to keep
-   the fp constant for the caller, so after ctf_simple_open_internal() returns,
-   we use memcpy to swap the interior of the old and new ctf_file_t's, and then
-   free the old.  */
+/* Compatibility: just update the threshold for ctf_discard.  */
 int
 ctf_update (ctf_file_t *fp)
+{
+  if (!(fp->ctf_flags & LCTF_RDWR))
+    return (ctf_set_errno (fp, ECTF_RDONLY));
+
+  fp->ctf_dtoldid = fp->ctf_typemax;
+  return 0;
+}
+
+/* If the specified CTF container is writable and has been modified, reload this
+   container with the updated type definitions, ready for serialization.  In
+   order to make this code and the rest of libctf as simple as possible, we
+   perform updates by taking the dynamic type definitions and creating an
+   in-memory CTF file containing the definitions, and then call
+   ctf_simple_open_internal() on it.  We perform one extra trick here for the
+   benefit of callers and to keep our code simple: ctf_simple_open_internal()
+   will return a new ctf_file_t, but we want to keep the fp constant for the
+   caller, so after ctf_simple_open_internal() returns, we use memcpy to swap
+   the interior of the old and new ctf_file_t's, and then free the old.  */
+int
+ctf_serialize (ctf_file_t *fp)
 {
   ctf_file_t ofp, *nfp;
   ctf_header_t hdr, *hdrp;
@@ -335,8 +394,7 @@  ctf_update (ctf_file_t *fp)
       uint32_t encoding;
       size_t len;
       ctf_stype_t *copied;
-
-      dtd->dtd_data.ctt_name = 0;
+      const char *name;
 
       if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
 	len = sizeof (ctf_stype_t);
@@ -345,8 +403,9 @@  ctf_update (ctf_file_t *fp)
 
       memcpy (t, &dtd->dtd_data, len);
       copied = (ctf_stype_t *) t;  /* name is at the start: constant offset.  */
-      if (dtd->dtd_name)
-	ctf_str_add_ref (fp, dtd->dtd_name, &copied->ctt_name);
+      if (copied->ctt_name
+	  && (name = ctf_strraw (fp, copied->ctt_name)) != NULL)
+	ctf_str_add_ref (fp, name, &copied->ctt_name);
       t += len;
 
       switch (kind)
@@ -448,7 +507,7 @@  ctf_update (ctf_file_t *fp)
 
   if ((nfp = ctf_simple_open_internal ((char *) buf, buf_size, NULL, 0,
 				       0, NULL, 0, fp->ctf_syn_ext_strtab,
-				       &err)) == NULL)
+				       1, &err)) == NULL)
     {
       ctf_free (buf);
       return (ctf_set_errno (fp, err));
@@ -463,15 +522,16 @@  ctf_update (ctf_file_t *fp)
     nfp->ctf_dynbase = buf;		/* Make sure buf is freed on close.  */
   nfp->ctf_dthash = fp->ctf_dthash;
   nfp->ctf_dtdefs = fp->ctf_dtdefs;
-  nfp->ctf_dtbyname = fp->ctf_dtbyname;
   nfp->ctf_dvhash = fp->ctf_dvhash;
   nfp->ctf_dvdefs = fp->ctf_dvdefs;
-  nfp->ctf_dtnextid = fp->ctf_dtnextid;
-  nfp->ctf_dtoldid = fp->ctf_dtnextid - 1;
+  nfp->ctf_dtoldid = fp->ctf_dtoldid;
   nfp->ctf_snapshots = fp->ctf_snapshots + 1;
   nfp->ctf_specific = fp->ctf_specific;
+  nfp->ctf_ptrtab = fp->ctf_ptrtab;
+  nfp->ctf_ptrtab_len = fp->ctf_ptrtab_len;
   nfp->ctf_link_inputs = fp->ctf_link_inputs;
   nfp->ctf_link_outputs = fp->ctf_link_outputs;
+  nfp->ctf_str_prov_offset = fp->ctf_str_prov_offset;
   nfp->ctf_syn_ext_strtab = fp->ctf_syn_ext_strtab;
   nfp->ctf_link_cu_mapping = fp->ctf_link_cu_mapping;
   nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
@@ -480,12 +540,20 @@  ctf_update (ctf_file_t *fp)
 
   nfp->ctf_snapshot_lu = fp->ctf_snapshots;
 
-  fp->ctf_dtbyname = NULL;
+  memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
+  nfp->ctf_structs = fp->ctf_structs;
+  nfp->ctf_unions = fp->ctf_unions;
+  nfp->ctf_enums = fp->ctf_enums;
+  nfp->ctf_names = fp->ctf_names;
+
   fp->ctf_dthash = NULL;
   ctf_str_free_atoms (nfp);
   nfp->ctf_str_atoms = fp->ctf_str_atoms;
+  nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
   fp->ctf_str_atoms = NULL;
+  fp->ctf_prov_strtab = NULL;
   memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
+  fp->ctf_ptrtab = NULL;
   fp->ctf_link_inputs = NULL;
   fp->ctf_link_outputs = NULL;
   fp->ctf_syn_ext_strtab = NULL;
@@ -494,63 +562,54 @@  ctf_update (ctf_file_t *fp)
 
   fp->ctf_dvhash = NULL;
   memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
+  memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
+  fp->ctf_structs.ctn_writable = NULL;
+  fp->ctf_unions.ctn_writable = NULL;
+  fp->ctf_enums.ctn_writable = NULL;
+  fp->ctf_names.ctn_writable = NULL;
 
   memcpy (&ofp, fp, sizeof (ctf_file_t));
   memcpy (fp, nfp, sizeof (ctf_file_t));
   memcpy (nfp, &ofp, sizeof (ctf_file_t));
 
-  /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
-     array of type name prefixes and the corresponding ctf_dynhash to use.
-     NOTE: This code must be kept in sync with the code in ctf_bufopen().  */
-
-  fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
-  fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
-  fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
-  fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
-
   nfp->ctf_refcnt = 1;		/* Force nfp to be freed.  */
   ctf_file_close (nfp);
 
   return 0;
 }
 
-static char *
-ctf_prefixed_name (int kind, const char *name)
+ctf_names_t *
+ctf_name_table (ctf_file_t *fp, int kind)
 {
-  char *prefixed;
-
   switch (kind)
     {
     case CTF_K_STRUCT:
-      prefixed = ctf_strdup ("struct ");
-      break;
+      return &fp->ctf_structs;
     case CTF_K_UNION:
-      prefixed = ctf_strdup ("union ");
-      break;
+      return &fp->ctf_unions;
     case CTF_K_ENUM:
-      prefixed = ctf_strdup ("enum ");
-      break;
+      return &fp->ctf_enums;
     default:
-      prefixed = ctf_strdup ("");
+      return &fp->ctf_names;
     }
-
-  prefixed = ctf_str_append (prefixed, name);
-  return prefixed;
 }
 
 int
-ctf_dtd_insert (ctf_file_t *fp, ctf_dtdef_t *dtd)
+ctf_dtd_insert (ctf_file_t *fp, ctf_dtdef_t *dtd, int kind)
 {
+  const char *name;
   if (ctf_dynhash_insert (fp->ctf_dthash, (void *) dtd->dtd_type, dtd) < 0)
     return -1;
 
-  if (dtd->dtd_name)
+  if (dtd->dtd_data.ctt_name
+      && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
     {
-      int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
-      if (ctf_dynhash_insert (fp->ctf_dtbyname,
-			      ctf_prefixed_name (kind, dtd->dtd_name),
-			      dtd) < 0)
-	return -1;
+      if (ctf_dynhash_insert (ctf_name_table (fp, kind)->ctn_writable,
+			      (char *) name, (void *) dtd->dtd_type) < 0)
+	{
+	  ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
+	  return -1;
+	}
     }
   ctf_list_append (&fp->ctf_dtdefs, dtd);
   return 0;
@@ -561,6 +620,7 @@  ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
 {
   ctf_dmdef_t *dmd, *nmd;
   int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
+  const char *name;
 
   ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 
@@ -583,14 +643,12 @@  ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
       break;
     }
 
-  if (dtd->dtd_name)
+  if (dtd->dtd_data.ctt_name
+      && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
     {
-      char *name;
-
-      name = ctf_prefixed_name (kind, dtd->dtd_name);
-      ctf_dynhash_remove (fp->ctf_dtbyname, name);
-      free (name);
-      ctf_free (dtd->dtd_name);
+      ctf_dynhash_remove (ctf_name_table (fp, kind)->ctn_writable,
+			  name);
+      ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
     }
 
   ctf_list_delete (&fp->ctf_dtdefs, dtd);
@@ -603,33 +661,20 @@  ctf_dtd_lookup (const ctf_file_t *fp, ctf_id_t type)
   return (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dthash, (void *) type);
 }
 
-static ctf_id_t
-ctf_dtd_lookup_type_by_name (ctf_file_t *fp, int kind, const char *name)
-{
-  ctf_dtdef_t *dtd;
-  char *decorated = ctf_prefixed_name (kind, name);
-
-  dtd = (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dtbyname, decorated);
-  free (decorated);
-
-  if (dtd)
-    return dtd->dtd_type;
-
-  return 0;
-}
-
 ctf_dtdef_t *
 ctf_dynamic_type (const ctf_file_t *fp, ctf_id_t id)
 {
   ctf_id_t idx;
 
+  if (!(fp->ctf_flags & LCTF_RDWR))
+    return NULL;
+
   if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, id))
     fp = fp->ctf_parent;
 
   idx = LCTF_TYPE_TO_INDEX(fp, id);
 
-  if (((unsigned long) idx > fp->ctf_typemax) &&
-      ((unsigned long) idx < fp->ctf_dtnextid))
+  if ((unsigned long) idx <= fp->ctf_typemax)
     return ctf_dtd_lookup (fp, id);
   return NULL;
 }
@@ -684,7 +729,7 @@  ctf_snapshot_id_t
 ctf_snapshot (ctf_file_t *fp)
 {
   ctf_snapshot_id_t snapid;
-  snapid.dtd_id = fp->ctf_dtnextid - 1;
+  snapid.dtd_id = fp->ctf_typemax;
   snapid.snapshot_id = fp->ctf_snapshots++;
   return snapid;
 }
@@ -699,19 +744,30 @@  ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
   if (!(fp->ctf_flags & LCTF_RDWR))
     return (ctf_set_errno (fp, ECTF_RDONLY));
 
-  if (fp->ctf_dtoldid > id.dtd_id)
-    return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
-
   if (fp->ctf_snapshot_lu >= id.snapshot_id)
     return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
 
   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
     {
+      int kind;
+      const char *name;
+
       ntd = ctf_list_next (dtd);
 
       if (LCTF_TYPE_TO_INDEX (fp, dtd->dtd_type) <= id.dtd_id)
 	continue;
 
+      kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
+
+      if (dtd->dtd_data.ctt_name
+	  && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
+	{
+	  ctf_dynhash_remove (ctf_name_table (fp, kind)->ctn_writable,
+			      name);
+	  ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
+	}
+
+      ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
       ctf_dtd_delete (fp, dtd);
     }
 
@@ -725,7 +781,7 @@  ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
       ctf_dvd_delete (fp, dvd);
     }
 
-  fp->ctf_dtnextid = id.dtd_id + 1;
+  fp->ctf_typemax = id.dtd_id;
   fp->ctf_snapshots = id.snapshot_id;
 
   if (fp->ctf_snapshots == fp->ctf_snapshot_lu)
@@ -735,12 +791,11 @@  ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
 }
 
 static ctf_id_t
-ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name,
+ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
 		 ctf_dtdef_t **rp)
 {
   ctf_dtdef_t *dtd;
   ctf_id_t type;
-  char *s = NULL;
 
   if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
     return (ctf_set_errno (fp, EINVAL));
@@ -748,29 +803,33 @@  ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name,
   if (!(fp->ctf_flags & LCTF_RDWR))
     return (ctf_set_errno (fp, ECTF_RDONLY));
 
-  if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_dtnextid, 1) > CTF_MAX_TYPE)
+  if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) >= CTF_MAX_TYPE)
     return (ctf_set_errno (fp, ECTF_FULL));
 
-  if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_dtnextid, 1) == CTF_MAX_PTYPE)
+  if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) == (CTF_MAX_PTYPE - 1))
     return (ctf_set_errno (fp, ECTF_FULL));
 
+  /* Make sure ptrtab always grows to be big enough for all types.  */
+  if (ctf_grow_ptrtab (fp) < 0)
+      return CTF_ERR;		/* errno is set for us. */
+
   if ((dtd = ctf_alloc (sizeof (ctf_dtdef_t))) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
-  if (name != NULL && (s = ctf_strdup (name)) == NULL)
-    {
-      ctf_free (dtd);
-      return (ctf_set_errno (fp, EAGAIN));
-    }
-
-  type = fp->ctf_dtnextid++;
+  type = ++fp->ctf_typemax;
   type = LCTF_INDEX_TO_TYPE (fp, type, (fp->ctf_flags & LCTF_CHILD));
 
   memset (dtd, 0, sizeof (ctf_dtdef_t));
-  dtd->dtd_name = s;
+  dtd->dtd_data.ctt_name = ctf_str_add_ref (fp, name, &dtd->dtd_data.ctt_name);
   dtd->dtd_type = type;
 
-  if (ctf_dtd_insert (fp, dtd) < 0)
+  if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
+    {
+      ctf_free (dtd);
+      return (ctf_set_errno (fp, EAGAIN));
+    }
+
+  if (ctf_dtd_insert (fp, dtd, kind) < 0)
     {
       ctf_free (dtd);
       return CTF_ERR;			/* errno is set for us.  */
@@ -808,7 +867,7 @@  ctf_add_encoded (ctf_file_t *fp, uint32_t flag,
   if (ep == NULL)
     return (ctf_set_errno (fp, EINVAL));
 
-  if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
@@ -825,6 +884,7 @@  ctf_add_reftype (ctf_file_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
   ctf_dtdef_t *dtd;
   ctf_id_t type;
   ctf_file_t *tmp = fp;
+  int child = fp->ctf_flags & LCTF_CHILD;
 
   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
     return (ctf_set_errno (fp, EINVAL));
@@ -832,12 +892,38 @@  ctf_add_reftype (ctf_file_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
   if (ctf_lookup_by_id (&tmp, ref) == NULL)
     return CTF_ERR;		/* errno is set for us.  */
 
-  if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, NULL, kind, &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
   dtd->dtd_data.ctt_type = (uint32_t) ref;
 
+  if (kind != CTF_K_POINTER)
+    return type;
+
+  /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
+     type and (if an anonymous typedef node is being pointed at) the type that
+     points at too.  Note that ctf_typemax is at this point one higher than we
+     want to check against, because it's just been incremented for the addition
+     of this type.  */
+
+  uint32_t type_idx = LCTF_TYPE_TO_INDEX (fp, type);
+  uint32_t ref_idx = LCTF_TYPE_TO_INDEX (fp, ref);
+
+  if (LCTF_TYPE_ISCHILD (fp, ref) == child
+      && ref_idx < fp->ctf_typemax)
+    {
+      fp->ctf_ptrtab[ref_idx] = type_idx;
+
+      ctf_id_t refref_idx = LCTF_TYPE_TO_INDEX (fp, dtd->dtd_data.ctt_type);
+
+      if (tmp == fp
+	  && (LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) == CTF_K_TYPEDEF)
+	  && strcmp (ctf_strptr (fp, dtd->dtd_data.ctt_name), "") == 0
+	  && refref_idx < fp->ctf_typemax)
+	fp->ctf_ptrtab[refref_idx] = type_idx;
+    }
+
   return type;
 }
 
@@ -868,7 +954,7 @@  ctf_add_slice (ctf_file_t *fp, uint32_t flag, ctf_id_t ref,
       (kind != CTF_K_ENUM))
     return (ctf_set_errno (fp, ECTF_NOTINTFP));
 
-  if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE, &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
@@ -918,7 +1004,7 @@  ctf_add_array (ctf_file_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
   if (ctf_lookup_by_id (&tmp, arp->ctr_index) == NULL)
     return CTF_ERR;		/* errno is set for us.  */
 
-  if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY, &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
@@ -981,7 +1067,8 @@  ctf_add_function (ctf_file_t *fp, uint32_t flag,
   if (vlen != 0 && (vdat = ctf_alloc (sizeof (ctf_id_t) * vlen)) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
-  if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
+			       &dtd)) == CTF_ERR)
     {
       ctf_free (vdat);
       return CTF_ERR;		   /* errno is set for us.  */
@@ -1002,22 +1089,18 @@  ctf_id_t
 ctf_add_struct_sized (ctf_file_t *fp, uint32_t flag, const char *name,
 		      size_t size)
 {
-  ctf_hash_t *hp = fp->ctf_structs;
   ctf_dtdef_t *dtd;
   ctf_id_t type = 0;
 
   /* Promote forwards to structs.  */
 
   if (name != NULL)
-    {
-      type = ctf_hash_lookup_type (hp, fp, name);
-      if (type == 0)
-	type = ctf_dtd_lookup_type_by_name (fp, CTF_K_STRUCT, name);
-    }
+    type = ctf_lookup_by_rawname (fp, CTF_K_STRUCT, name);
 
   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
     dtd = ctf_dtd_lookup (fp, type);
-  else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  else if ((type = ctf_add_generic (fp, flag, name, CTF_K_STRUCT,
+				    &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
@@ -1044,21 +1127,17 @@  ctf_id_t
 ctf_add_union_sized (ctf_file_t *fp, uint32_t flag, const char *name,
 		     size_t size)
 {
-  ctf_hash_t *hp = fp->ctf_unions;
   ctf_dtdef_t *dtd;
   ctf_id_t type = 0;
 
   /* Promote forwards to unions.  */
   if (name != NULL)
-    {
-      type = ctf_hash_lookup_type (hp, fp, name);
-      if (type == 0)
-	type = ctf_dtd_lookup_type_by_name (fp, CTF_K_UNION, name);
-    }
+    type = ctf_lookup_by_rawname (fp, CTF_K_UNION, name);
 
   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
     dtd = ctf_dtd_lookup (fp, type);
-  else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  else if ((type = ctf_add_generic (fp, flag, name, CTF_K_UNION,
+				    &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
@@ -1084,21 +1163,17 @@  ctf_add_union (ctf_file_t *fp, uint32_t flag, const char *name)
 ctf_id_t
 ctf_add_enum (ctf_file_t *fp, uint32_t flag, const char *name)
 {
-  ctf_hash_t *hp = fp->ctf_enums;
   ctf_dtdef_t *dtd;
   ctf_id_t type = 0;
 
   /* Promote forwards to enums.  */
   if (name != NULL)
-    {
-      type = ctf_hash_lookup_type (hp, fp, name);
-      if (type == 0)
-	type = ctf_dtd_lookup_type_by_name (fp, CTF_K_ENUM, name);
-    }
+    type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
 
   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
     dtd = ctf_dtd_lookup (fp, type);
-  else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  else if ((type = ctf_add_generic (fp, flag, name, CTF_K_ENUM,
+				    &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
@@ -1111,7 +1186,6 @@  ctf_id_t
 ctf_add_enum_encoded (ctf_file_t *fp, uint32_t flag, const char *name,
 		      const ctf_encoding_t *ep)
 {
-  ctf_hash_t *hp = fp->ctf_enums;
   ctf_id_t type = 0;
 
   /* First, create the enum if need be, using most of the same machinery as
@@ -1120,11 +1194,7 @@  ctf_add_enum_encoded (ctf_file_t *fp, uint32_t flag, const char *name,
      slice, which would be a useless thing to do anyway.)  */
 
   if (name != NULL)
-    {
-      type = ctf_hash_lookup_type (hp, fp, name);
-      if (type == 0)
-	type = ctf_dtd_lookup_type_by_name (fp, CTF_K_ENUM, name);
-    }
+    type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
 
   if (type != 0)
     {
@@ -1144,36 +1214,19 @@  ctf_id_t
 ctf_add_forward (ctf_file_t *fp, uint32_t flag, const char *name,
 		 uint32_t kind)
 {
-  ctf_hash_t *hp;
   ctf_dtdef_t *dtd;
   ctf_id_t type = 0;
 
-  switch (kind)
-    {
-    case CTF_K_STRUCT:
-      hp = fp->ctf_structs;
-      break;
-    case CTF_K_UNION:
-      hp = fp->ctf_unions;
-      break;
-    case CTF_K_ENUM:
-      hp = fp->ctf_enums;
-      break;
-    default:
-      return (ctf_set_errno (fp, ECTF_NOTSUE));
-    }
+  if (kind != CTF_K_STRUCT && kind != CTF_K_UNION && kind != CTF_K_ENUM)
+    return (ctf_set_errno (fp, ECTF_NOTSUE));
 
   /* If the type is already defined or exists as a forward tag, just
      return the ctf_id_t of the existing definition.  */
 
   if (name != NULL)
-    {
-      if (((type = ctf_hash_lookup_type (hp, fp, name)) != 0)
-	  || (type = ctf_dtd_lookup_type_by_name (fp, kind, name)) != 0)
-	return type;
-    }
+    type = ctf_lookup_by_rawname (fp, kind, name);
 
-  if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, name, CTF_K_FORWARD,&dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
@@ -1196,7 +1249,8 @@  ctf_add_typedef (ctf_file_t *fp, uint32_t flag, const char *name,
   if (ctf_lookup_by_id (&tmp, ref) == NULL)
     return CTF_ERR;		/* errno is set for us.  */
 
-  if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
+  if ((type = ctf_add_generic (fp, flag, name, CTF_K_TYPEDEF,
+			       &dtd)) == CTF_ERR)
     return CTF_ERR;		/* errno is set for us.  */
 
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
@@ -1567,7 +1621,6 @@  ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
   ctf_dtdef_t *dtd;
   ctf_funcinfo_t ctc;
 
-  ctf_hash_t *hp;
   ctf_id_t orig_src_type = src_type;
 
   if (!(dst_fp->ctf_flags & LCTF_RDWR))
@@ -1589,28 +1642,12 @@  ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
   if (kind == CTF_K_FORWARD)
     forward_kind = src_tp->ctt_type;
 
-  switch (forward_kind)
-    {
-    case CTF_K_STRUCT:
-      hp = dst_fp->ctf_structs;
-      break;
-    case CTF_K_UNION:
-      hp = dst_fp->ctf_unions;
-      break;
-    case CTF_K_ENUM:
-      hp = dst_fp->ctf_enums;
-      break;
-    default:
-      hp = dst_fp->ctf_names;
-      break;
-    }
-
   /* If the source type has a name and is a root type (visible at the
      top-level scope), lookup the name in the destination container and
      verify that it is of the same kind before we do anything else.  */
 
   if ((flag & CTF_ADD_ROOT) && name[0] != '\0'
-      && (tmp = ctf_hash_lookup_type (hp, dst_fp, name)) != 0)
+      && (tmp = ctf_lookup_by_rawname (dst_fp, forward_kind, name)) != 0)
     {
       dst_type = tmp;
       dst_kind = ctf_type_kind_unsliced (dst_fp, dst_type);
@@ -1708,8 +1745,12 @@  ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
 	     && LCTF_TYPE_TO_INDEX (src_fp, dtd->dtd_type) > dst_fp->ctf_dtoldid;
 	   dtd = ctf_list_prev (dtd))
 	{
-	  if (LCTF_INFO_KIND (src_fp, dtd->dtd_data.ctt_info) == kind
-	      && dtd->dtd_name != NULL && strcmp (dtd->dtd_name, name) == 0)
+          const char *ctt_name;
+
+          if (LCTF_INFO_KIND (src_fp, dtd->dtd_data.ctt_info) == kind
+	      && dtd->dtd_data.ctt_name
+              && ((ctt_name = ctf_strraw (src_fp, dtd->dtd_data.ctt_name)) != NULL)
+              && strcmp (ctt_name, name) == 0)
 	    {
 	      int sroot;	/* Is the src root-visible?  */
 	      int droot;	/* Is the dst root-visible?  */
@@ -1888,7 +1929,7 @@  ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
 	   manually so as to avoid repeated lookups in ctf_add_member
 	   and to ensure the exact same member offsets as in src_type.  */
 
-	dst_type = ctf_add_generic (dst_fp, flag, name, &dtd);
+	dst_type = ctf_add_generic (dst_fp, flag, name, kind, &dtd);
 	if (dst_type == CTF_ERR)
 	  return CTF_ERR;			/* errno is set for us.  */
 
@@ -2032,18 +2073,20 @@  ctf_compress_write (ctf_file_t *fp, int fd)
   ctf_header_t *hp = &h;
   ssize_t header_len = sizeof (ctf_header_t);
   ssize_t compress_len;
-  size_t max_compress_len = compressBound (fp->ctf_size);
   ssize_t len;
   int rc;
   int err = 0;
 
+  if (ctf_serialize (fp) < 0)
+    return -1;					/* errno is set for us.  */
+
   memcpy (hp, fp->ctf_header, header_len);
   hp->cth_flags |= CTF_F_COMPRESS;
+  compress_len = compressBound (fp->ctf_size);
 
-  if ((buf = ctf_alloc (max_compress_len)) == NULL)
+  if ((buf = ctf_alloc (compress_len)) == NULL)
     return (ctf_set_errno (fp, ECTF_ZALLOC));
 
-  compress_len = max_compress_len;
   if ((rc = compress (buf, (uLongf *) &compress_len,
 		      fp->ctf_buf, fp->ctf_size)) != Z_OK)
     {
@@ -2090,12 +2133,15 @@  ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
   ctf_header_t *hp;
   ssize_t header_len = sizeof (ctf_header_t);
   ssize_t compress_len;
-  size_t max_compress_len = compressBound (fp->ctf_size);
   int rc;
 
+  if (ctf_serialize (fp) < 0)
+    return NULL;				/* errno is set for us.  */
+
+  compress_len = compressBound (fp->ctf_size);
   if (fp->ctf_size < threshold)
-    max_compress_len = fp->ctf_size;
-  if ((buf = malloc (max_compress_len
+    compress_len = fp->ctf_size;
+  if ((buf = malloc (compress_len
 		     + sizeof (struct ctf_header))) == NULL)
     {
       ctf_set_errno (fp, ENOMEM);
@@ -2107,8 +2153,6 @@  ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
   bp = buf + sizeof (struct ctf_header);
   *size = sizeof (struct ctf_header);
 
-  compress_len = max_compress_len;
-
   if (fp->ctf_size < threshold)
     {
       hp->cth_flags &= ~CTF_F_COMPRESS;
@@ -2139,6 +2183,9 @@  ctf_write (ctf_file_t *fp, int fd)
   ssize_t resid;
   ssize_t len;
 
+  if (ctf_serialize (fp) < 0)
+    return -1;					/* errno is set for us.  */
+
   resid = sizeof (ctf_header_t);
   buf = (unsigned char *) fp->ctf_header;
   while (resid != 0)
diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index ab8f4c18b33..83bf2b34b8f 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -89,11 +89,17 @@  typedef struct ctf_dmodel
   size_t ctd_long;		/* Size of long in bytes.  */
 } ctf_dmodel_t;
 
+typedef struct ctf_names
+{
+  ctf_hash_t *ctn_readonly;	/* Hash table when readonly.  */
+  ctf_dynhash_t *ctn_writable;	/* Hash table when writable.  */
+} ctf_names_t;
+
 typedef struct ctf_lookup
 {
   const char *ctl_prefix;	/* String prefix for this lookup.  */
   size_t ctl_len;		/* Length of prefix string in bytes.  */
-  ctf_hash_t *ctl_hash;		/* Pointer to hash table for lookup.  */
+  ctf_names_t *ctl_hash;	/* Pointer to hash table for lookup.  */
 } ctf_lookup_t;
 
 typedef struct ctf_fileops
@@ -152,9 +158,8 @@  typedef struct ctf_dmdef
 typedef struct ctf_dtdef
 {
   ctf_list_t dtd_list;		/* List forward/back pointers.  */
-  char *dtd_name;		/* Name associated with definition (if any).  */
   ctf_id_t dtd_type;		/* Type identifier for this definition.  */
-  ctf_type_t dtd_data;		/* Type node: name left unpopulated.  */
+  ctf_type_t dtd_data;		/* Type node, including name.  */
   union
   {
     ctf_list_t dtu_members;	/* struct, union, or enum */
@@ -193,7 +198,8 @@  typedef struct ctf_str_atom
 {
   const char *csa_str;		/* Backpointer to string (hash key).  */
   ctf_list_t csa_refs;		/* This string's refs.  */
-  uint32_t csa_offset;		/* External strtab offset, if any.  */
+  uint32_t csa_offset;		/* Strtab offset, if any.  */
+  uint32_t csa_external_offset;	/* External strtab offset, if any.  */
   unsigned long csa_snapshot_id; /* Snapshot ID at time of creation.  */
 } ctf_str_atom_t;
 
@@ -235,17 +241,20 @@  struct ctf_file
   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.  */
+  ctf_dynhash_t *ctf_prov_strtab;   /* Maps provisional-strtab offsets
+				       to names.  */
   ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names.  */
   void *ctf_data_mmapped;	    /* CTF data we mmapped, to free later.  */
   size_t ctf_data_mmapped_len;	    /* Length of CTF data we mmapped.  */
-  ctf_hash_t *ctf_structs;	    /* Hash table of struct types.  */
-  ctf_hash_t *ctf_unions;	    /* Hash table of union types.  */
-  ctf_hash_t *ctf_enums;	    /* Hash table of enum types.  */
-  ctf_hash_t *ctf_names;	    /* Hash table of remaining type names.  */
-  ctf_lookup_t ctf_lookups[5];	    /* Pointers to hashes for name lookup.  */
+  ctf_names_t ctf_structs;	    /* Hash table of struct types.  */
+  ctf_names_t ctf_unions;	    /* Hash table of union types.  */
+  ctf_names_t ctf_enums;	    /* Hash table of enum types.  */
+  ctf_names_t ctf_names;	    /* Hash table of remaining type names.  */
+  ctf_lookup_t ctf_lookups[5];	    /* Pointers to nametabs for name lookup.  */
   ctf_strs_t ctf_str[2];	    /* Array of string table base and bounds.  */
   ctf_dynhash_t *ctf_str_atoms;	  /* Hash table of ctf_str_atoms_t.  */
   uint64_t ctf_str_num_refs;	  /* Number of refs to cts_str_atoms.  */
+  uint32_t ctf_str_prov_offset;	  /* Latest provisional offset assigned so far.  */
   unsigned char *ctf_base;	  /* CTF file pointer.  */
   unsigned char *ctf_dynbase;	  /* Freeable CTF file pointer. */
   unsigned char *ctf_buf;	  /* Uncompressed CTF data buffer.  */
@@ -254,6 +263,7 @@  struct ctf_file
   unsigned long ctf_nsyms;	  /* Number of entries in symtab xlate table.  */
   uint32_t *ctf_txlate;		  /* Translation table for type IDs.  */
   uint32_t *ctf_ptrtab;		  /* Translation table for pointer-to lookups.  */
+  size_t ctf_ptrtab_len;	  /* Num types storable in ptrtab currently.  */
   struct ctf_varent *ctf_vars;	  /* Sorted variable->type mapping.  */
   unsigned long ctf_nvars;	  /* Number of variables in ctf_vars.  */
   unsigned long ctf_typemax;	  /* Maximum valid type ID number.  */
@@ -270,11 +280,9 @@  struct ctf_file
   int ctf_errno;		  /* Error code for most recent error.  */
   int ctf_version;		  /* CTF data version.  */
   ctf_dynhash_t *ctf_dthash;	  /* Hash of dynamic type definitions.  */
-  ctf_dynhash_t *ctf_dtbyname;	  /* DTDs, indexed by name.  */
   ctf_list_t ctf_dtdefs;	  /* List of dynamic type definitions.  */
   ctf_dynhash_t *ctf_dvhash;	  /* Hash of dynamic variable mappings.  */
   ctf_list_t ctf_dvdefs;	  /* List of dynamic variable definitions.  */
-  unsigned long ctf_dtnextid;	  /* Next dynamic type id to assign.  */
   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.  */
@@ -320,7 +328,10 @@  struct ctf_archive_internal
 					   (id))
 
 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
-  ((ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
+    ((fp->ctf_flags & LCTF_RDWR) ?					\
+     &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE				\
+		       (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))
@@ -340,7 +351,11 @@  static inline ssize_t ctf_get_ctt_size (const ctf_file_t *fp,
 #define LCTF_RDWR	0x0002	/* CTF container is writable */
 #define LCTF_DIRTY	0x0004	/* CTF container 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 *);
 
 typedef unsigned int (*ctf_hash_fun) (const void *ptr);
 extern unsigned int ctf_hash_integer (const void *ptr);
@@ -381,8 +396,9 @@  extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f,
 extern void ctf_list_append (ctf_list_t *, void *);
 extern void ctf_list_prepend (ctf_list_t *, void *);
 extern void ctf_list_delete (ctf_list_t *, void *);
+extern int ctf_list_empty_p (ctf_list_t *lp);
 
-extern int ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *);
+extern int ctf_dtd_insert (ctf_file_t *, ctf_dtdef_t *, int);
 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);
@@ -410,9 +426,10 @@  extern const char *ctf_strraw_explicit (ctf_file_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 const char *ctf_str_add (ctf_file_t *, const char *);
-extern const char *ctf_str_add_ref (ctf_file_t *, const char *, uint32_t *ref);
-extern const char *ctf_str_add_external (ctf_file_t *, const char *, uint32_t offset);
+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 *);
@@ -426,10 +443,11 @@  extern unsigned long ctf_set_errno (ctf_file_t *, int);
 extern ctf_file_t *ctf_simple_open_internal (const char *, size_t, const char *,
 					     size_t, size_t,
 					     const char *, size_t,
-					     ctf_dynhash_t *, int *);
+					     ctf_dynhash_t *, int, int *);
 extern ctf_file_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *,
 					 const ctf_sect_t *, ctf_dynhash_t *,
-					 int *);
+					 int, int *);
+extern int ctf_serialize (ctf_file_t *);
 
 _libctf_malloc_
 extern void *ctf_mmap (size_t length, size_t offset, int fd);
diff --git a/libctf/ctf-link.c b/libctf/ctf-link.c
index 94625bbaf3c..726c0e92c75 100644
--- a/libctf/ctf-link.c
+++ b/libctf/ctf-link.c
@@ -639,7 +639,7 @@  ctf_link_intern_extern_string (void *key _libctf_unused_, void *value,
   ctf_link_out_string_cb_arg_t *arg = (ctf_link_out_string_cb_arg_t *) arg_;
 
   fp->ctf_flags |= LCTF_DIRTY;
-  if (ctf_str_add_external (fp, arg->str, arg->offset) == NULL)
+  if (!ctf_str_add_external (fp, arg->str, arg->offset))
     arg->err = ENOMEM;
 }
 
@@ -662,7 +662,7 @@  ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string,
       ctf_link_out_string_cb_arg_t iter_arg = { str, offset, 0 };
 
       fp->ctf_flags |= LCTF_DIRTY;
-      if (ctf_str_add_external (fp, str, offset) == NULL)
+      if (!ctf_str_add_external (fp, str, offset))
 	err = ENOMEM;
 
       ctf_dynhash_iter (fp->ctf_link_outputs, ctf_link_intern_extern_string,
@@ -693,8 +693,7 @@  typedef struct ctf_name_list_accum_cb_arg
   size_t ndynames;
 } ctf_name_list_accum_cb_arg_t;
 
-/* Accumulate the names and a count of the names in the link output hash,
-   and run ctf_update() on them to generate them.  */
+/* Accumulate the names and a count of the names in the link output hash.  */
 static void
 ctf_accumulate_archive_names (void *key, void *value, void *arg_)
 {
@@ -703,13 +702,6 @@  ctf_accumulate_archive_names (void *key, void *value, void *arg_)
   char **names;
   ctf_file_t **files;
   ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_;
-  int err;
-
-  if ((err = ctf_update (fp)) < 0)
-    {
-      ctf_set_errno (arg->fp, ctf_errno (fp));
-      return;
-    }
 
   if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL)
     {
@@ -788,12 +780,6 @@  ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold)
   memset (&arg, 0, sizeof (ctf_name_list_accum_cb_arg_t));
   arg.fp = fp;
 
-  if (ctf_update (fp) < 0)
-    {
-      errloc = "CTF file construction";
-      goto err;
-    }
-
   if (fp->ctf_link_outputs)
     {
       ctf_dynhash_iter (fp->ctf_link_outputs, ctf_accumulate_archive_names, &arg);
diff --git a/libctf/ctf-lookup.c b/libctf/ctf-lookup.c
index 40eaf9c819d..6f180d68c2e 100644
--- a/libctf/ctf-lookup.c
+++ b/libctf/ctf-lookup.c
@@ -161,8 +161,8 @@  ctf_lookup_by_name (ctf_file_t *fp, const char *name)
 		    }
 		}
 
-	      if ((type = ctf_hash_lookup_type (lp->ctl_hash, fp,
-						fp->ctf_tmp_typeslice)) == 0)
+	      if ((type = ctf_lookup_by_rawhash (fp, lp->ctl_hash,
+						 fp->ctf_tmp_typeslice)) == 0)
 		{
 		  (void) ctf_set_errno (fp, ECTF_NOTYPE);
 		  goto err;
@@ -322,13 +322,6 @@  ctf_lookup_by_id (ctf_file_t **fpp, ctf_id_t type)
       return NULL;
     }
 
-  idx = LCTF_TYPE_TO_INDEX (fp, type);
-  if (idx > 0 && (unsigned long) idx <= fp->ctf_typemax)
-    {
-      *fpp = fp;		/* Function returns ending CTF container.  */
-      return (LCTF_INDEX_TO_TYPEPTR (fp, idx));
-    }
-
   /* If this container is writable, check for a dynamic type.  */
 
   if (fp->ctf_flags & LCTF_RDWR)
@@ -340,7 +333,19 @@  ctf_lookup_by_id (ctf_file_t **fpp, ctf_id_t type)
 	  *fpp = fp;
 	  return &dtd->dtd_data;
 	}
+      (void) ctf_set_errno (*fpp, ECTF_BADID);
+      return NULL;
     }
+
+  /* Check for a type in the static portion.  */
+
+  idx = LCTF_TYPE_TO_INDEX (fp, type);
+  if (idx > 0 && (unsigned long) idx <= fp->ctf_typemax)
+    {
+      *fpp = fp;		/* Function returns ending CTF container.  */
+      return (LCTF_INDEX_TO_TYPEPTR (fp, idx));
+    }
+
   (void) ctf_set_errno (*fpp, ECTF_BADID);
   return NULL;
 }
diff --git a/libctf/ctf-open.c b/libctf/ctf-open.c
index 25f0e9e8ad1..c4fca243391 100644
--- a/libctf/ctf-open.c
+++ b/libctf/ctf-open.c
@@ -655,7 +655,6 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 
   unsigned long pop[CTF_K_MAX + 1] = { 0 };
   const ctf_type_t *tp;
-  ctf_hash_t *hp;
   uint32_t id, dst;
   uint32_t *xp;
 
@@ -666,6 +665,8 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
   int nlstructs = 0, nlunions = 0;
   int err;
 
+  assert (!(fp->ctf_flags & LCTF_RDWR));
+
   if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1))
     {
       int err;
@@ -717,32 +718,37 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
   /* Now that we've counted up the number of each type, we can allocate
      the hash tables, type translation table, and pointer table.  */
 
-  if ((fp->ctf_structs = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string,
-					  ctf_hash_eq_string)) == NULL)
+  if ((fp->ctf_structs.ctn_readonly
+       = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string,
+			  ctf_hash_eq_string)) == NULL)
     return ENOMEM;
 
-  if ((fp->ctf_unions = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string,
-					 ctf_hash_eq_string)) == NULL)
+  if ((fp->ctf_unions.ctn_readonly
+       = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string,
+			  ctf_hash_eq_string)) == NULL)
     return ENOMEM;
 
-  if ((fp->ctf_enums = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string,
-					ctf_hash_eq_string)) == NULL)
+  if ((fp->ctf_enums.ctn_readonly
+       = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string,
+			  ctf_hash_eq_string)) == NULL)
     return ENOMEM;
 
-  if ((fp->ctf_names = ctf_hash_create (pop[CTF_K_INTEGER] +
-					pop[CTF_K_FLOAT] +
-					pop[CTF_K_FUNCTION] +
-					pop[CTF_K_TYPEDEF] +
-					pop[CTF_K_POINTER] +
-					pop[CTF_K_VOLATILE] +
-					pop[CTF_K_CONST] +
-					pop[CTF_K_RESTRICT],
-					ctf_hash_string,
-					ctf_hash_eq_string)) == NULL)
+  if ((fp->ctf_names.ctn_readonly
+       = ctf_hash_create (pop[CTF_K_INTEGER] +
+			  pop[CTF_K_FLOAT] +
+			  pop[CTF_K_FUNCTION] +
+			  pop[CTF_K_TYPEDEF] +
+			  pop[CTF_K_POINTER] +
+			  pop[CTF_K_VOLATILE] +
+			  pop[CTF_K_CONST] +
+			  pop[CTF_K_RESTRICT],
+			  ctf_hash_string,
+			  ctf_hash_eq_string)) == NULL)
     return ENOMEM;
 
   fp->ctf_txlate = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
-  fp->ctf_ptrtab = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
+  fp->ctf_ptrtab_len = fp->ctf_typemax + 1;
+  fp->ctf_ptrtab = ctf_alloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
 
   if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
     return ENOMEM;		/* Memory allocation failed.  */
@@ -779,10 +785,11 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	     root-visible version so that we can be sure to find it when
 	     checking for conflicting definitions in ctf_add_type().  */
 
-	  if (((ctf_hash_lookup_type (fp->ctf_names, fp, name)) == 0)
+	  if (((ctf_hash_lookup_type (fp->ctf_names.ctn_readonly,
+				      fp, name)) == 0)
 	      || (flag & CTF_ADD_ROOT))
 	    {
-	      err = ctf_hash_define_type (fp->ctf_names, fp,
+	      err = ctf_hash_define_type (fp->ctf_names.ctn_readonly, fp,
 					  LCTF_INDEX_TO_TYPE (fp, id, child),
 					  tp->ctt_name);
 	      if (err != 0)
@@ -797,7 +804,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_FUNCTION:
-	  err = ctf_hash_insert_type (fp->ctf_names, fp,
+	  err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 	  if (err != 0)
@@ -805,7 +812,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_STRUCT:
-	  err = ctf_hash_define_type (fp->ctf_structs, fp,
+	  err = ctf_hash_define_type (fp->ctf_structs.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 
@@ -817,7 +824,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_UNION:
-	  err = ctf_hash_define_type (fp->ctf_unions, fp,
+	  err = ctf_hash_define_type (fp->ctf_unions.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 
@@ -829,7 +836,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_ENUM:
-	  err = ctf_hash_define_type (fp->ctf_enums, fp,
+	  err = ctf_hash_define_type (fp->ctf_enums.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 
@@ -838,7 +845,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_TYPEDEF:
-	  err = ctf_hash_insert_type (fp->ctf_names, fp,
+	  err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 	  if (err != 0)
@@ -846,32 +853,20 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	  break;
 
 	case CTF_K_FORWARD:
-	  /* Only insert forward tags into the given hash if the type or tag
-	     name is not already present.  */
-	  switch (tp->ctt_type)
-	    {
-	    case CTF_K_STRUCT:
-	      hp = fp->ctf_structs;
-	      break;
-	    case CTF_K_UNION:
-	      hp = fp->ctf_unions;
-	      break;
-	    case CTF_K_ENUM:
-	      hp = fp->ctf_enums;
-	      break;
-	    default:
-	      hp = fp->ctf_structs;
-	    }
-
-	  if (ctf_hash_lookup_type (hp, fp, name) == 0)
-	    {
-	      err = ctf_hash_insert_type (hp, fp,
-					  LCTF_INDEX_TO_TYPE (fp, id, child),
-					  tp->ctt_name);
-	      if (err != 0)
-		return err;
-	    }
-	  break;
+	  {
+	    ctf_names_t *np = ctf_name_table (fp, tp->ctt_type);
+	    /* Only insert forward tags into the given hash if the type or tag
+	       name is not already present.  */
+	    if (ctf_hash_lookup_type (np->ctn_readonly, fp, name) == 0)
+	      {
+		err = ctf_hash_insert_type (np->ctn_readonly, fp,
+					    LCTF_INDEX_TO_TYPE (fp, id, child),
+					    tp->ctt_name);
+		if (err != 0)
+		  return err;
+	      }
+	    break;
+	  }
 
 	case CTF_K_POINTER:
 	  /* If the type referenced by the pointer is in this CTF container,
@@ -886,7 +881,7 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	case CTF_K_VOLATILE:
 	case CTF_K_CONST:
 	case CTF_K_RESTRICT:
-	  err = ctf_hash_insert_type (fp->ctf_names, fp,
+	  err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp,
 				      LCTF_INDEX_TO_TYPE (fp, id, child),
 				      tp->ctt_name);
 	  if (err != 0)
@@ -903,12 +898,14 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
     }
 
   ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax);
-  ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp->ctf_enums));
+  ctf_dprintf ("%u enum names hashed\n",
+	       ctf_hash_size (fp->ctf_enums.ctn_readonly));
   ctf_dprintf ("%u struct names hashed (%d long)\n",
-	       ctf_hash_size (fp->ctf_structs), nlstructs);
+	       ctf_hash_size (fp->ctf_structs.ctn_readonly), nlstructs);
   ctf_dprintf ("%u union names hashed (%d long)\n",
-	       ctf_hash_size (fp->ctf_unions), nlunions);
-  ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp->ctf_names));
+	       ctf_hash_size (fp->ctf_unions.ctn_readonly), nlunions);
+  ctf_dprintf ("%u base type names hashed\n",
+	       ctf_hash_size (fp->ctf_names.ctn_readonly));
 
   /* Make an additional pass through the pointer table to find pointers that
      point to anonymous typedef nodes.  If we find one, modify the pointer table
@@ -921,11 +918,11 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 	{
 	  tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
 
-	  if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF &&
-	      strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0 &&
-	      LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child &&
-	      LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
-	    fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst;
+	  if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF
+	      && strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0
+	      && LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
+	      && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
+	      fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst;
 	}
     }
 
@@ -1197,6 +1194,29 @@  flip_ctf (ctf_header_t *cth, unsigned char *buf)
   return flip_types (buf + cth->cth_typeoff, cth->cth_stroff - cth->cth_typeoff);
 }
 
+/* Set up the ctl hashes in a ctf_file_t.  Called by both writable and
+   non-writable dictionary initialization.  */
+void ctf_set_ctl_hashes (ctf_file_t *fp)
+{
+  /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
+     array of type name prefixes and the corresponding ctf_hash to use.  */
+  fp->ctf_lookups[0].ctl_prefix = "struct";
+  fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
+  fp->ctf_lookups[0].ctl_hash = &fp->ctf_structs;
+  fp->ctf_lookups[1].ctl_prefix = "union";
+  fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
+  fp->ctf_lookups[1].ctl_hash = &fp->ctf_unions;
+  fp->ctf_lookups[2].ctl_prefix = "enum";
+  fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
+  fp->ctf_lookups[2].ctl_hash = &fp->ctf_enums;
+  fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
+  fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
+  fp->ctf_lookups[3].ctl_hash = &fp->ctf_names;
+  fp->ctf_lookups[4].ctl_prefix = NULL;
+  fp->ctf_lookups[4].ctl_len = 0;
+  fp->ctf_lookups[4].ctl_hash = NULL;
+}
+
 /* Open a CTF file, mocking up a suitable ctf_sect.  */
 
 ctf_file_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
@@ -1207,7 +1227,7 @@  ctf_file_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size,
 {
   return ctf_simple_open_internal (ctfsect, ctfsect_size, symsect, symsect_size,
 				   symsect_entsize, strsect, strsect_size, NULL,
-				   errp);
+				   0, errp);
 }
 
 /* Open a CTF file, mocking up a suitable ctf_sect and overriding the external
@@ -1217,7 +1237,8 @@  ctf_file_t *ctf_simple_open_internal (const char *ctfsect, size_t ctfsect_size,
 				      const char *symsect, size_t symsect_size,
 				      size_t symsect_entsize,
 				      const char *strsect, size_t strsect_size,
-				      ctf_dynhash_t *syn_strtab, int *errp)
+				      ctf_dynhash_t *syn_strtab, int writable,
+				      int *errp)
 {
   ctf_sect_t skeleton;
 
@@ -1254,7 +1275,8 @@  ctf_file_t *ctf_simple_open_internal (const char *ctfsect, size_t ctfsect_size,
       strsectp = &str_sect;
     }
 
-  return ctf_bufopen_internal (ctfsectp, symsectp, strsectp, syn_strtab, errp);
+  return ctf_bufopen_internal (ctfsectp, symsectp, strsectp, syn_strtab,
+			       writable, errp);
 }
 
 /* Decode the specified CTF buffer and optional symbol table, and create a new
@@ -1266,7 +1288,7 @@  ctf_file_t *
 ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 	     const ctf_sect_t *strsect, int *errp)
 {
-  return ctf_bufopen_internal (ctfsect, symsect, strsect, NULL, errp);
+  return ctf_bufopen_internal (ctfsect, symsect, strsect, NULL, 0, errp);
 }
 
 /* Like ctf_bufopen, but overriding the external strtab with a synthetic one.  */
@@ -1274,7 +1296,7 @@  ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 ctf_file_t *
 ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 		      const ctf_sect_t *strsect, ctf_dynhash_t *syn_strtab,
-		      int *errp)
+		      int writable, int *errp)
 {
   const ctf_preamble_t *pp;
   size_t hdrsz = sizeof (ctf_header_t);
@@ -1353,6 +1375,9 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 
   memset (fp, 0, sizeof (ctf_file_t));
 
+  if (writable)
+    fp->ctf_flags |= LCTF_RDWR;
+
   if ((fp->ctf_header = ctf_alloc (sizeof (struct ctf_header))) == NULL)
     {
       ctf_free (fp);
@@ -1366,7 +1391,6 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
   if (foreign_endian)
     flip_header (hp);
   fp->ctf_openflags = hp->cth_flags;
-
   fp->ctf_size = hp->cth_stroff + hp->cth_strlen;
 
   ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
@@ -1515,6 +1539,14 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 
   ctf_set_base (fp, hp, fp->ctf_base);
 
+  /* No need to do anything else for dynamic containers: they do not support
+     symbol lookups, and the type table is maintained in the dthashes.  */
+  if (fp->ctf_flags & LCTF_RDWR)
+    {
+      fp->ctf_refcnt = 1;
+      return fp;
+    }
+
   if ((err = init_types (fp, hp)) != 0)
     goto bad;
 
@@ -1538,24 +1570,7 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
 	goto bad;
     }
 
-  /* Initialize the ctf_lookup_by_name top-level dictionary.  We keep an
-     array of type name prefixes and the corresponding ctf_hash to use.
-     NOTE: This code must be kept in sync with the code in ctf_update().  */
-  fp->ctf_lookups[0].ctl_prefix = "struct";
-  fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix);
-  fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
-  fp->ctf_lookups[1].ctl_prefix = "union";
-  fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix);
-  fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
-  fp->ctf_lookups[2].ctl_prefix = "enum";
-  fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix);
-  fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
-  fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR;
-  fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix);
-  fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
-  fp->ctf_lookups[4].ctl_prefix = NULL;
-  fp->ctf_lookups[4].ctl_len = 0;
-  fp->ctf_lookups[4].ctl_hash = NULL;
+  ctf_set_ctl_hashes (fp);
 
   if (symsect != NULL)
     {
@@ -1608,7 +1623,20 @@  ctf_file_close (ctf_file_t *fp)
       ctf_dtd_delete (fp, dtd);
     }
   ctf_dynhash_destroy (fp->ctf_dthash);
-  ctf_dynhash_destroy (fp->ctf_dtbyname);
+  if (fp->ctf_flags & LCTF_RDWR)
+    {
+      ctf_dynhash_destroy (fp->ctf_structs.ctn_writable);
+      ctf_dynhash_destroy (fp->ctf_unions.ctn_writable);
+      ctf_dynhash_destroy (fp->ctf_enums.ctn_writable);
+      ctf_dynhash_destroy (fp->ctf_names.ctn_writable);
+    }
+  else
+    {
+      ctf_hash_destroy (fp->ctf_structs.ctn_readonly);
+      ctf_hash_destroy (fp->ctf_unions.ctn_readonly);
+      ctf_hash_destroy (fp->ctf_enums.ctn_readonly);
+      ctf_hash_destroy (fp->ctf_names.ctn_readonly);
+    }
 
   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
     {
@@ -1642,11 +1670,6 @@  ctf_file_close (ctf_file_t *fp)
   ctf_free (fp->ctf_txlate);
   ctf_free (fp->ctf_ptrtab);
 
-  ctf_hash_destroy (fp->ctf_structs);
-  ctf_hash_destroy (fp->ctf_unions);
-  ctf_hash_destroy (fp->ctf_enums);
-  ctf_hash_destroy (fp->ctf_names);
-
   ctf_free (fp->ctf_header);
   ctf_free (fp);
 }
@@ -1671,7 +1694,7 @@  ctf_get_arc (const ctf_file_t *fp)
    structure, not a pointer to it, since that is likely to become a pointer to
    freed data before the return value is used under the expected use case of
    ctf_getsect()/ ctf_file_close()/free().  */
-extern ctf_sect_t
+ctf_sect_t
 ctf_getdatasect (const ctf_file_t *fp)
 {
   return fp->ctf_data;
diff --git a/libctf/ctf-string.c b/libctf/ctf-string.c
index a90b9d242a4..20f4ab9f497 100644
--- a/libctf/ctf-string.c
+++ b/libctf/ctf-string.c
@@ -38,6 +38,16 @@  ctf_strraw_explicit (ctf_file_t *fp, uint32_t name, ctf_strs_t *strtab)
     return ctf_dynhash_lookup (fp->ctf_syn_ext_strtab,
                                (void *) (uintptr_t) name);
 
+  /* If the name is in the internal strtab, and the offset is beyond the end of
+     the ctsp->cts_len but below the ctf_str_prov_offset, this is a provisional
+     string added by ctf_str_add*() but not yet built into a real strtab: get
+     the value out of the ctf_prov_strtab.  */
+
+  if (CTF_NAME_STID (name) == CTF_STRTAB_0
+      && name >= ctsp->cts_len && name < fp->ctf_str_prov_offset)
+      return ctf_dynhash_lookup (fp->ctf_prov_strtab,
+				 (void *) (uintptr_t) name);
+
   if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET (name) < ctsp->cts_len)
     return (ctsp->cts_strs + CTF_NAME_OFFSET (name));
 
@@ -96,24 +106,45 @@  ctf_str_create_atoms (ctf_file_t *fp)
   if (fp->ctf_str_atoms == NULL)
     return -ENOMEM;
 
+  if (!fp->ctf_prov_strtab)
+    fp->ctf_prov_strtab = ctf_dynhash_create (ctf_hash_integer,
+					      ctf_hash_eq_integer,
+					      NULL, NULL);
+  if (!fp->ctf_prov_strtab)
+    goto oom_prov_strtab;
+
+  errno = 0;
   ctf_str_add (fp, "");
+  if (errno == ENOMEM)
+    goto oom_str_add;
+
   return 0;
+
+ oom_str_add:
+  ctf_dynhash_destroy (fp->ctf_prov_strtab);
+  fp->ctf_prov_strtab = NULL;
+ oom_prov_strtab:
+  ctf_dynhash_destroy (fp->ctf_str_atoms);
+  fp->ctf_str_atoms = NULL;
+  return -ENOMEM;
 }
 
 /* Destroy the atoms table.  */
 void
 ctf_str_free_atoms (ctf_file_t *fp)
 {
+  ctf_dynhash_destroy (fp->ctf_prov_strtab);
   ctf_dynhash_destroy (fp->ctf_str_atoms);
 }
 
 /* Add a string to the atoms table, copying the passed-in string.  Return the
    atom added. Return NULL only when out of memory (and do not touch the
    passed-in string in that case).  Possibly augment the ref list with the
-   passed-in ref.  */
+   passed-in ref.  Possibly add a provisional entry for this string to the
+   provisional strtab.   */
 static ctf_str_atom_t *
 ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
-			  int add_ref, uint32_t *ref)
+			  int add_ref, int make_provisional, uint32_t *ref)
 {
   char *newstr = NULL;
   ctf_str_atom_t *atom = NULL;
@@ -150,6 +181,18 @@  ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
 
   atom->csa_str = newstr;
   atom->csa_snapshot_id = fp->ctf_snapshots;
+
+  if (make_provisional)
+    {
+      atom->csa_offset = fp->ctf_str_prov_offset;
+
+      if (ctf_dynhash_insert (fp->ctf_prov_strtab, (void *) (uintptr_t)
+			      atom->csa_offset, (void *) atom->csa_str) < 0)
+	goto oom;
+
+      fp->ctf_str_prov_offset += strlen (atom->csa_str) + 1;
+    }
+
   if (add_ref)
     {
       ctf_list_append (&atom->csa_refs, aref);
@@ -158,59 +201,87 @@  ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
   return atom;
 
  oom:
+  if (newstr)
+    ctf_dynhash_remove (fp->ctf_str_atoms, newstr);
   ctf_free (atom);
   ctf_free (aref);
   ctf_free (newstr);
   return NULL;
 }
 
-/* Add a string to the atoms table and return it, without augmenting the ref
-   list for this string.  */
-const char *
+/* Add a string to the atoms table, without augmenting the ref list for this
+   string: return a 'provisional offset' which can be used to return this string
+   until ctf_str_write_strtab is called, or 0 on failure.  (Everywhere the
+   provisional offset is assigned to should be added as a ref using
+   ctf_str_add_ref() as well.) */
+uint32_t
 ctf_str_add (ctf_file_t *fp, const char *str)
 {
   ctf_str_atom_t *atom;
   if (!str)
-    return NULL;
+    return 0;
 
-  atom = ctf_str_add_ref_internal (fp, str, FALSE, 0);
+  atom = ctf_str_add_ref_internal (fp, str, FALSE, TRUE, 0);
   if (!atom)
-    return NULL;
+    return 0;
 
-  return atom->csa_str;
+  return atom->csa_offset;
 }
 
 /* Like ctf_str_add(), but additionally augment the atom's refs list with the
    passed-in ref, whether or not the string is already present.  There is no
    attempt to deduplicate the refs list (but duplicates are harmless).  */
-const char *
+uint32_t
 ctf_str_add_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
 {
   ctf_str_atom_t *atom;
   if (!str)
-    return NULL;
+    return 0;
 
-  atom = ctf_str_add_ref_internal (fp, str, TRUE, ref);
+  atom = ctf_str_add_ref_internal (fp, str, TRUE, TRUE, ref);
   if (!atom)
-    return NULL;
+    return 0;
 
-  return atom->csa_str;
+  return atom->csa_offset;
 }
 
-/* Add an external strtab reference at OFFSET.  */
-const char *
+/* Add an external strtab reference at OFFSET.  Returns zero if the addition
+   failed, nonzero otherwise.  */
+int
 ctf_str_add_external (ctf_file_t *fp, const char *str, uint32_t offset)
 {
   ctf_str_atom_t *atom;
   if (!str)
-    return NULL;
+    return 0;
+
+  atom = ctf_str_add_ref_internal (fp, str, FALSE, FALSE, 0);
+  if (!atom)
+    return 0;
+
+  atom->csa_external_offset = CTF_SET_STID (offset, CTF_STRTAB_1);
+  return 1;
+}
 
-  atom = ctf_str_add_ref_internal (fp, str, FALSE, 0);
+/* Remove a single ref.  */
+void
+ctf_str_remove_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
+{
+  ctf_str_atom_ref_t *aref, *anext;
+  ctf_str_atom_t *atom = NULL;
+
+  atom = ctf_dynhash_lookup (fp->ctf_str_atoms, str);
   if (!atom)
-    return NULL;
+    return;
 
-  atom->csa_offset = CTF_SET_STID (offset, CTF_STRTAB_1);
-  return atom->csa_str;
+  for (aref = ctf_list_next (&atom->csa_refs); aref != NULL; aref = anext)
+    {
+      anext = ctf_list_next (aref);
+      if (aref->caf_ref == ref)
+	{
+	  ctf_list_delete (&atom->csa_refs, aref);
+	  ctf_free (aref);
+	}
+    }
 }
 
 /* A ctf_dynhash_iter_remove() callback that removes atoms later than a given
@@ -285,12 +356,25 @@  ctf_str_count_strtab (void *key _libctf_unused_, void *value,
   ctf_str_atom_t *atom = (ctf_str_atom_t *) value;
   ctf_strtab_write_state_t *s = (ctf_strtab_write_state_t *) arg;
 
-  /* We only factor in the length of items that have no offset:
-     other items are in the external strtab.  They still contribute to the
-     total count, though, because we still have to sort them.  */
-  if (!atom->csa_offset)
-    s->strtab->cts_len += strlen (atom->csa_str) + 1;
-  s->strtab_count++;
+  /* We only factor in the length of items that have no offset and have refs:
+     other items are in the external strtab, or will simply not be written out
+     at all.  They still contribute to the total count, though, because we still
+     have to sort them.  We add in the null string's length explicitly, outside
+     this function, since it is explicitly written out even if it has no refs at
+     all.  */
+
+  if (s->nullstr == atom)
+    {
+      s->strtab_count++;
+      return;
+    }
+
+  if (!ctf_list_empty_p (&atom->csa_refs))
+    {
+      if (!atom->csa_external_offset)
+	s->strtab->cts_len += strlen (atom->csa_str) + 1;
+      s->strtab_count++;
+    }
 }
 
 /* Populate the sorttab with pointers to the strtab atoms.  */
@@ -305,7 +389,9 @@  ctf_str_populate_sorttab (void *key _libctf_unused_, void *value,
   if (s->nullstr == atom)
     return;
 
-  s->sorttab[s->i++] = atom;
+  /* Skip atoms with no refs.  */
+  if (!ctf_list_empty_p (&atom->csa_refs))
+    s->sorttab[s->i++] = atom;
 }
 
 /* Sort the strtab.  */
@@ -346,7 +432,9 @@  ctf_str_write_strtab (ctf_file_t *fp)
       return strtab;
     }
 
+  s.nullstr = nullstr;
   ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_count_strtab, &s);
+  strtab.cts_len++;				/* For the null string.  */
 
   ctf_dprintf ("%lu bytes of strings in strtab.\n",
 	       (unsigned long) strtab.cts_len);
@@ -359,7 +447,6 @@  ctf_str_write_strtab (ctf_file_t *fp)
   sorttab[0] = nullstr;
   s.i = 1;
   s.sorttab = sorttab;
-  s.nullstr = nullstr;
   ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_populate_sorttab, &s);
 
   qsort (&sorttab[1], s.strtab_count - 1, sizeof (ctf_str_atom_t *),
@@ -378,7 +465,7 @@  ctf_str_write_strtab (ctf_file_t *fp)
   /* Update all refs: also update the strtab appropriately.  */
   for (i = 0; i < s.strtab_count; i++)
     {
-      if (sorttab[i]->csa_offset)
+      if (sorttab[i]->csa_external_offset)
 	{
 	  /* External strtab entry: populate the synthetic external strtab.
 
@@ -388,17 +475,21 @@  ctf_str_write_strtab (ctf_file_t *fp)
 	     until ctf_file_close.  */
 
 	  any_external = 1;
-	  ctf_str_update_refs (sorttab[i], sorttab[i]->csa_offset);
+	  ctf_str_update_refs (sorttab[i], sorttab[i]->csa_external_offset);
 	  if (ctf_dynhash_insert (fp->ctf_syn_ext_strtab,
-				  (void *) (uintptr_t) sorttab[i]->csa_offset,
+				  (void *) (uintptr_t)
+				  sorttab[i]->csa_external_offset,
 				  (void *) sorttab[i]->csa_str) < 0)
 	    goto oom_strtab;
+	  sorttab[i]->csa_offset = sorttab[i]->csa_external_offset;
 	}
       else
 	{
-	  /* Internal strtab entry: actually add to the string table.  */
+	  /* Internal strtab entry with refs: actually add to the string
+	     table.  */
 
 	  ctf_str_update_refs (sorttab[i], cur_stroff);
+	  sorttab[i]->csa_offset = cur_stroff;
 	  strcpy (&strtab.cts_strs[cur_stroff], sorttab[i]->csa_str);
 	  cur_stroff += strlen (sorttab[i]->csa_str) + 1;
 	}
@@ -411,6 +502,12 @@  ctf_str_write_strtab (ctf_file_t *fp)
       fp->ctf_syn_ext_strtab = NULL;
     }
 
+  /* All the provisional strtab entries are now real strtab entries, and
+     ctf_strptr() will find them there.  The provisional offset now starts right
+     beyond the new end of the strtab.  */
+
+  ctf_dynhash_empty (fp->ctf_prov_strtab);
+  fp->ctf_str_prov_offset = strtab.cts_len + 1;
   return strtab;
 
  oom_strtab:
diff --git a/libctf/ctf-types.c b/libctf/ctf-types.c
index 9fe4d5a6d73..6e677622343 100644
--- a/libctf/ctf-types.c
+++ b/libctf/ctf-types.c
@@ -42,6 +42,7 @@  ctf_member_iter (ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
 {
   ctf_file_t *ofp = fp;
   const ctf_type_t *tp;
+  ctf_dtdef_t *dtd;
   ssize_t size, increment;
   uint32_t kind, n;
   int rc;
@@ -58,29 +59,43 @@  ctf_member_iter (ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
     return (ctf_set_errno (ofp, ECTF_NOTSOU));
 
-  if (size < CTF_LSTRUCT_THRESH)
+  if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
     {
-      const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
-						       increment);
-
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+      if (size < CTF_LSTRUCT_THRESH)
 	{
-	  const char *name = ctf_strptr (fp, mp->ctm_name);
-	  if ((rc = func (name, mp->ctm_type, mp->ctm_offset, arg)) != 0)
+	  const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
+							   increment);
+
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+	    {
+	      const char *name = ctf_strptr (fp, mp->ctm_name);
+	      if ((rc = func (name, mp->ctm_type, mp->ctm_offset, arg)) != 0)
 	    return rc;
+	    }
 	}
+      else
+	{
+	  const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
+							      increment);
 
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
+	    {
+	      const char *name = ctf_strptr (fp, lmp->ctlm_name);
+	      if ((rc = func (name, lmp->ctlm_type,
+			      (unsigned long) CTF_LMEM_OFFSET (lmp), arg)) != 0)
+		return rc;
+	    }
+	}
     }
   else
     {
-      const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
-							  increment);
+      ctf_dmdef_t *dmd;
 
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
 	{
-	  const char *name = ctf_strptr (fp, lmp->ctlm_name);
-	  if ((rc = func (name, lmp->ctlm_type,
-			  (unsigned long) CTF_LMEM_OFFSET (lmp), arg)) != 0)
+	  if ((rc = func (dmd->dmd_name, dmd->dmd_type,
+			  dmd->dmd_offset, arg)) != 0)
 	    return rc;
 	}
     }
@@ -97,6 +112,7 @@  ctf_enum_iter (ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
   ctf_file_t *ofp = fp;
   const ctf_type_t *tp;
   const ctf_enum_t *ep;
+  ctf_dtdef_t *dtd;
   ssize_t increment;
   uint32_t n;
   int rc;
@@ -112,13 +128,27 @@  ctf_enum_iter (ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
 
   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
 
-  ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
+  if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
+    {
+      ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
 
-  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+	{
+	  const char *name = ctf_strptr (fp, ep->cte_name);
+	  if ((rc = func (name, ep->cte_value, arg)) != 0)
+	    return rc;
+	}
+    }
+  else
     {
-      const char *name = ctf_strptr (fp, ep->cte_name);
-      if ((rc = func (name, ep->cte_value, arg)) != 0)
-	return rc;
+      ctf_dmdef_t *dmd;
+
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
+	{
+	  if ((rc = func (dmd->dmd_name, dmd->dmd_value, arg)) != 0)
+	    return rc;
+	}
     }
 
   return 0;
@@ -171,16 +201,30 @@  ctf_type_iter_all (ctf_file_t *fp, ctf_type_all_f *func, void *arg)
 int
 ctf_variable_iter (ctf_file_t *fp, ctf_variable_f *func, void *arg)
 {
-  unsigned long i;
   int rc;
 
   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
     return ECTF_NOPARENT;
 
-  for (i = 0; i < fp->ctf_nvars; i++)
-    if ((rc = func (ctf_strptr (fp, fp->ctf_vars[i].ctv_name),
-		    fp->ctf_vars[i].ctv_type, arg)) != 0)
-      return rc;
+  if (!(fp->ctf_flags & LCTF_RDWR))
+    {
+      unsigned long i;
+      for (i = 0; i < fp->ctf_nvars; i++)
+	if ((rc = func (ctf_strptr (fp, fp->ctf_vars[i].ctv_name),
+			fp->ctf_vars[i].ctv_type, arg)) != 0)
+	  return rc;
+    }
+  else
+    {
+      ctf_dvdef_t *dvd;
+
+      for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
+	   dvd = ctf_list_next (dvd))
+	{
+	  if ((rc = func (dvd->dvd_name, dvd->dvd_type, arg)) != 0)
+	    return rc;
+	}
+    }
 
   return 0;
 }
@@ -249,6 +293,29 @@  ctf_type_resolve_unsliced (ctf_file_t *fp, ctf_id_t type)
   return type;
 }
 
+/* Look up a name in the given name table, in the appropriate hash given the
+   kind of the identifier.  The name is a raw, undecorated identifier.  */
+
+ctf_id_t ctf_lookup_by_rawname (ctf_file_t *fp, int kind, const char *name)
+{
+  return ctf_lookup_by_rawhash (fp, ctf_name_table (fp, kind), name);
+}
+
+/* Look up a name in the given name table, in the appropriate hash given the
+   readability state of the dictionary.  The name is a raw, undecorated
+   identifier.  */
+
+ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *fp, ctf_names_t *np, const char *name)
+{
+  ctf_id_t id;
+
+  if (fp->ctf_flags & LCTF_RDWR)
+    id = (ctf_id_t) ctf_dynhash_lookup (np->ctn_writable, name);
+  else
+    id = ctf_hash_lookup_type (np->ctn_readonly, fp, name);
+  return id;
+}
+
 /* Lookup the given type ID and return its name as a new dynamcally-allocated
    string.  */
 
@@ -829,6 +896,7 @@  ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
 {
   ctf_file_t *ofp = fp;
   const ctf_type_t *tp;
+  ctf_dtdef_t *dtd;
   ssize_t size, increment;
   uint32_t kind, n;
 
@@ -844,32 +912,50 @@  ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
     return (ctf_set_errno (ofp, ECTF_NOTSOU));
 
-  if (size < CTF_LSTRUCT_THRESH)
+  if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
     {
-      const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
-						       increment);
+      if (size < CTF_LSTRUCT_THRESH)
+	{
+	  const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
+							   increment);
 
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+	    {
+	      if (strcmp (ctf_strptr (fp, mp->ctm_name), name) == 0)
+		{
+		  mip->ctm_type = mp->ctm_type;
+		  mip->ctm_offset = mp->ctm_offset;
+		  return 0;
+		}
+	    }
+	}
+      else
 	{
-	  if (strcmp (ctf_strptr (fp, mp->ctm_name), name) == 0)
+	  const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
+							      increment);
+
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
 	    {
-	      mip->ctm_type = mp->ctm_type;
-	      mip->ctm_offset = mp->ctm_offset;
-	      return 0;
+	      if (strcmp (ctf_strptr (fp, lmp->ctlm_name), name) == 0)
+		{
+		  mip->ctm_type = lmp->ctlm_type;
+		  mip->ctm_offset = (unsigned long) CTF_LMEM_OFFSET (lmp);
+		  return 0;
+		}
 	    }
 	}
     }
   else
     {
-      const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
-							  increment);
+      ctf_dmdef_t *dmd;
 
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
 	{
-	  if (strcmp (ctf_strptr (fp, lmp->ctlm_name), name) == 0)
+	  if (strcmp (dmd->dmd_name, name) == 0)
 	    {
-	      mip->ctm_type = lmp->ctlm_type;
-	      mip->ctm_offset = (unsigned long) CTF_LMEM_OFFSET (lmp);
+	      mip->ctm_type = dmd->dmd_type;
+	      mip->ctm_offset = dmd->dmd_offset;
 	      return 0;
 	    }
 	}
@@ -920,6 +1006,7 @@  ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
   ctf_file_t *ofp = fp;
   const ctf_type_t *tp;
   const ctf_enum_t *ep;
+  const ctf_dtdef_t *dtd;
   ssize_t increment;
   uint32_t n;
 
@@ -937,12 +1024,26 @@  ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
 
   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
 
-  ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
+  if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
+    {
+      ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
 
-  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+	{
+	  if (ep->cte_value == value)
+	    return (ctf_strptr (fp, ep->cte_name));
+	}
+    }
+  else
     {
-      if (ep->cte_value == value)
-	return (ctf_strptr (fp, ep->cte_name));
+      ctf_dmdef_t *dmd;
+
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
+	{
+	  if (dmd->dmd_value == value)
+	    return dmd->dmd_name;
+	}
     }
 
   (void) ctf_set_errno (ofp, ECTF_NOENUMNAM);
@@ -958,6 +1059,7 @@  ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
   ctf_file_t *ofp = fp;
   const ctf_type_t *tp;
   const ctf_enum_t *ep;
+  const ctf_dtdef_t *dtd;
   ssize_t increment;
   uint32_t n;
 
@@ -977,13 +1079,31 @@  ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
 
   ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
 
-  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+  if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
     {
-      if (strcmp (ctf_strptr (fp, ep->cte_name), name) == 0)
+      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
 	{
-	  if (valp != NULL)
-	    *valp = ep->cte_value;
-	  return 0;
+	  if (strcmp (ctf_strptr (fp, ep->cte_name), name) == 0)
+	    {
+	      if (valp != NULL)
+		*valp = ep->cte_value;
+	      return 0;
+	    }
+	}
+    }
+  else
+    {
+      ctf_dmdef_t *dmd;
+
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
+	{
+	  if (strcmp (dmd->dmd_name, name) == 0)
+	    {
+	      if (valp != NULL)
+		*valp = dmd->dmd_value;
+	      return 0;
+	    }
 	}
     }
 
@@ -1000,6 +1120,7 @@  ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
   const ctf_type_t *tp;
   uint32_t kind;
   const uint32_t *args;
+  const ctf_dtdef_t *dtd;
   ssize_t size, increment;
 
   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
@@ -1015,10 +1136,13 @@  ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
     return (ctf_set_errno (fp, ECTF_NOTFUNC));
 
   fip->ctc_return = tp->ctt_type;
-  fip->ctc_argc = LCTF_INFO_VLEN (fp, tp->ctt_info);
   fip->ctc_flags = 0;
+  fip->ctc_argc = LCTF_INFO_VLEN (fp, tp->ctt_info);
 
-  args = (uint32_t *) ((uintptr_t) tp + increment);
+  if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
+    args = (uint32_t *) ((uintptr_t) tp + increment);
+  else
+    args = (uint32_t *) dtd->dtd_u.dtu_argv;
 
   if (fip->ctc_argc != 0 && args[fip->ctc_argc - 1] == 0)
     {
@@ -1037,6 +1161,7 @@  ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv
 {
   const ctf_type_t *tp;
   const uint32_t *args;
+  const ctf_dtdef_t *dtd;
   ssize_t size, increment;
   ctf_funcinfo_t f;
 
@@ -1051,7 +1176,10 @@  ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv
 
   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 
-  args = (uint32_t *) ((uintptr_t) tp + increment);
+  if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
+    args = (uint32_t *) ((uintptr_t) tp + increment);
+  else
+    args = (uint32_t *) dtd->dtd_u.dtu_argv;
 
   for (argc = MIN (argc, f.ctc_argc); argc != 0; argc--)
     *argv++ = *args++;
@@ -1071,6 +1199,7 @@  ctf_type_rvisit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func,
 {
   ctf_id_t otype = type;
   const ctf_type_t *tp;
+  const ctf_dtdef_t *dtd;
   ssize_t size, increment;
   uint32_t kind, n;
   int rc;
@@ -1091,32 +1220,48 @@  ctf_type_rvisit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func,
 
   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 
-  if (size < CTF_LSTRUCT_THRESH)
+  if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
     {
-      const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
-						       increment);
-
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+      if (size < CTF_LSTRUCT_THRESH)
 	{
-	  if ((rc = ctf_type_rvisit (fp, mp->ctm_type,
-				     func, arg, ctf_strptr (fp, mp->ctm_name),
-				     offset + mp->ctm_offset,
-				     depth + 1)) != 0)
-	    return rc;
+	  const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
+							   increment);
+
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
+	    {
+	      if ((rc = ctf_type_rvisit (fp, mp->ctm_type,
+					 func, arg, ctf_strptr (fp,
+								mp->ctm_name),
+					 offset + mp->ctm_offset,
+					 depth + 1)) != 0)
+		return rc;
+	    }
 	}
+      else
+	{
+	  const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
+							      increment);
 
+	  for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
+	    {
+	      if ((rc = ctf_type_rvisit (fp, lmp->ctlm_type,
+					 func, arg, ctf_strptr (fp,
+								lmp->ctlm_name),
+					 offset + (unsigned long) CTF_LMEM_OFFSET (lmp),
+					 depth + 1)) != 0)
+		return rc;
+	    }
+	}
     }
   else
     {
-      const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
-							  increment);
+      ctf_dmdef_t *dmd;
 
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
+      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+	   dmd != NULL; dmd = ctf_list_next (dmd))
 	{
-	  if ((rc = ctf_type_rvisit (fp, lmp->ctlm_type,
-				     func, arg, ctf_strptr (fp,
-							    lmp->ctlm_name),
-				     offset + (unsigned long) CTF_LMEM_OFFSET (lmp),
+	  if ((rc = ctf_type_rvisit (fp, dmd->dmd_type, func, arg,
+				     dmd->dmd_name, dmd->dmd_offset,
 				     depth + 1)) != 0)
 	    return rc;
 	}
diff --git a/libctf/ctf-util.c b/libctf/ctf-util.c
index b813c0d4141..f27c7685200 100644
--- a/libctf/ctf-util.c
+++ b/libctf/ctf-util.c
@@ -80,6 +80,14 @@  ctf_list_delete (ctf_list_t *lp, void *existing)
     lp->l_prev = p->l_prev;
 }
 
+/* Return 1 if the list is empty.  */
+
+int
+ctf_list_empty_p (ctf_list_t *lp)
+{
+  return (lp->l_next == NULL && lp->l_prev == NULL);
+}
+
 /* Convert a 32-bit ELF symbol into Elf64 and return a pointer to it.  */
 
 Elf64_Sym *