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, 115 insertions, 91 deletions

diff --git a/libctf/ctf-open.c b/libctf/ctf-open.c
index 9dcd274..c4fca24 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);
@@ -1514,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;
 
@@ -1537,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)
     {
@@ -1607,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)
     {
@@ -1641,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);
 }
@@ -1670,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;