libctf: avoid the need to ever use ctf_update

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.

v5: fix tabdamage.

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.

1 files changed, 235 insertions, 188 deletions

diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 466777a..16e7de8 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,23 +239,30 @@ 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;
   ctf_dtdef_t *dtd;
@@ -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))
 	{
+	  const char *ctt_name;
+
 	  if (LCTF_INFO_KIND (src_fp, dtd->dtd_data.ctt_info) == kind
-	      && dtd->dtd_name != NULL && strcmp (dtd->dtd_name, name) == 0)
+	      && 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)