/* CTF string table management.   Copyright (C) 2019-2026 Free Software Foundation, Inc.    This file is part of libctf.    libctf is free software; you can redistribute it and/or modify it under   the terms of the GNU General Public License as published by the Free   Software Foundation; either version 3, or (at your option) any later   version.    This program is distributed in the hope that it will be useful, but   WITHOUT ANY WARRANTY; without even the implied warranty of   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License for more details.    You should have received a copy of the GNU General Public License   along with this program; see the file COPYING.  If not see   <http://www.gnu.org/licenses/>.  */ #include <assert.h>#include <ctf-impl.h>#include <string.h> static ctf_str_atom_t *ctf_str_add_ref_internal (ctf_dict_t *fp, const char *str,			  int flags, uint32_t *ref); /* Convert an encoded CTF string name into a pointer to a C string, possibly  using an explicit internal provisional strtab rather than the fp-based  one.  */const char *ctf_strraw_explicit (ctf_dict_t *fp, uint32_t name, ctf_strs_t *strtab){  ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID (name)];   if ((CTF_NAME_STID (name) == CTF_STRTAB_0) && (strtab != NULL))    ctsp = strtab;   /* If this name is in the external strtab, and there is a synthetic     strtab, use it in preference.  (This is used to add the set of strings     -- symbol names, etc -- the linker knows about before the strtab is     written out.)  */   if (CTF_NAME_STID (name) == CTF_STRTAB_1      && fp->ctf_syn_ext_strtab != NULL)    return ctf_dynhash_lookup (fp->ctf_syn_ext_strtab,			       (void *) (uintptr_t) name);   /* If the name is in the internal strtab, and the name 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));   /* String table not loaded or corrupt offset.  */  return NULL;} /* Convert an encoded CTF string name into a pointer to a C string by looking  up the appropriate string table buffer and then adding the offset.  */const char *ctf_strraw (ctf_dict_t *fp, uint32_t name){  return ctf_strraw_explicit (fp, name, NULL);} /* Return a guaranteed-non-NULL pointer to the string with the given CTF   name.  */const char *ctf_strptr (ctf_dict_t *fp, uint32_t name){  const char *s = ctf_strraw (fp, name);  return (s != NULL ? s : "(?)");} /* As above, but return info on what is wrong in more detail.   (Used for type lookups.) */ const char *ctf_strptr_validate (ctf_dict_t *fp, uint32_t name){  const char *str = ctf_strraw (fp, name);   if (str == NULL)    {      if (CTF_NAME_STID (name) == CTF_STRTAB_1	  && fp->ctf_syn_ext_strtab == NULL	  && fp->ctf_str[CTF_NAME_STID (name)].cts_strs == NULL)	{	  ctf_set_errno (fp, ECTF_STRTAB);	  return NULL;	}       ctf_set_errno (fp, ECTF_BADNAME);      return NULL;    }  return str;} /* Remove all refs to a given atom.  */static voidctf_str_purge_atom_refs (ctf_str_atom_t *atom){  ctf_str_atom_ref_t *ref, *next;  ctf_str_atom_ref_movable_t *movref, *movnext;   for (ref = ctf_list_next (&atom->csa_refs); ref != NULL; ref = next)    {      next = ctf_list_next (ref);      ctf_list_delete (&atom->csa_refs, ref);      free (ref);    }   for (movref = ctf_list_next (&atom->csa_movable_refs);       movref != NULL; movref = movnext)    {      movnext = ctf_list_next (movref);      ctf_list_delete (&atom->csa_movable_refs, movref);       ctf_dynhash_remove (movref->caf_movable_refs, movref);       free (movref);    }} /* Free an atom.  */static voidctf_str_free_atom (void *a){  ctf_str_atom_t *atom = a;   ctf_str_purge_atom_refs (atom);   if (atom->csa_flags & CTF_STR_ATOM_FREEABLE)    free (atom->csa_str);   free (atom);} /* Create the atoms table.  There is always at least one atom in it, the null   string: but also pull in atoms from the internal strtab.  (We rely on   calls to ctf_str_add_external to populate external strtab entries, since   these are often not quite the same as what appears in any external   strtab, and the external strtab is often huge and best not aggressively   pulled in.)  */intctf_str_create_atoms (ctf_dict_t *fp){  size_t i;   fp->ctf_str_atoms = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,					  NULL, ctf_str_free_atom);  if (!fp->ctf_str_atoms)    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;   fp->ctf_str_movable_refs = ctf_dynhash_create (ctf_hash_integer,						 ctf_hash_eq_integer,						 NULL, NULL);  if (!fp->ctf_str_movable_refs)    goto oom_movable_refs;   errno = 0;  ctf_str_add (fp, "");  if (errno == ENOMEM)    goto oom_str_add;   /* Pull in all the strings in the strtab as new atoms.  The provisional     strtab must be empty at this point, so there is no need to populate     atoms from it as well.  Types in this subset are frozen and readonly,     so the refs list and movable refs list need not be populated.  */   for (i = 0; i < fp->ctf_str[CTF_STRTAB_0].cts_len;       i += strlen (&fp->ctf_str[CTF_STRTAB_0].cts_strs[i]) + 1)    {      ctf_str_atom_t *atom;       if (fp->ctf_str[CTF_STRTAB_0].cts_strs[i] == 0)	continue;       atom = ctf_str_add_ref_internal (fp, &fp->ctf_str[CTF_STRTAB_0].cts_strs[i],				       0, 0);       if (!atom)	goto oom_str_add;       atom->csa_offset = i;    }   fp->ctf_str_prov_offset = fp->ctf_str[CTF_STRTAB_0].cts_len + 1;   return 0;  oom_str_add:  ctf_dynhash_destroy (fp->ctf_str_movable_refs);  fp->ctf_str_movable_refs = NULL; oom_movable_refs:  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 and associated refs.  */voidctf_str_free_atoms (ctf_dict_t *fp){  ctf_dynhash_destroy (fp->ctf_prov_strtab);  ctf_dynhash_destroy (fp->ctf_str_atoms);  ctf_dynhash_destroy (fp->ctf_str_movable_refs);  if (fp->ctf_dynstrtab)    {      free (fp->ctf_dynstrtab->cts_strs);      free (fp->ctf_dynstrtab);    }} #define CTF_STR_ADD_REF 0x1#define CTF_STR_PROVISIONAL 0x2#define CTF_STR_MOVABLE 0x4 /* Allocate a ref and bind it into a ref list.  */ static ctf_str_atom_ref_t *aref_create (ctf_dict_t *fp, ctf_str_atom_t *atom, uint32_t *ref, int flags){  ctf_str_atom_ref_t *aref;  size_t s = sizeof (struct ctf_str_atom_ref);   if (flags & CTF_STR_MOVABLE)    s = sizeof (struct ctf_str_atom_ref_movable);   aref = malloc (s);   if (!aref)    return NULL;   aref->caf_ref = ref;   /* Movable refs get a backpointer to them in ctf_str_movable_refs, and a     pointer to ctf_str_movable_refs itself in the ref, for use when freeing     refs: they can be moved later in batches via a call to     ctf_str_move_refs.  */   if (flags & CTF_STR_MOVABLE)    {      ctf_str_atom_ref_movable_t *movref = (ctf_str_atom_ref_movable_t *) aref;       movref->caf_movable_refs = fp->ctf_str_movable_refs;       if (ctf_dynhash_insert (fp->ctf_str_movable_refs, ref, aref) < 0)	{	  free (aref);	  return NULL;	}      ctf_list_append (&atom->csa_movable_refs, movref);    }  else    ctf_list_append (&atom->csa_refs, aref);   return aref;} /* Add a string to the atoms table, copying the passed-in string if   necessary.  Return the atom added. Return NULL only when out of memory   (and do not touch the passed-in string in that case).    Possibly add a provisional entry for this string to the provisional   strtab.  If the string is in the provisional strtab, update its ref list   with the passed-in ref, causing the ref to be updated when the strtab is   written out.  */ static ctf_str_atom_t *ctf_str_add_ref_internal (ctf_dict_t *fp, const char *str,			  int flags, uint32_t *ref){  char *newstr = NULL;  ctf_str_atom_t *atom = NULL;  int added = 0;   atom = ctf_dynhash_lookup (fp->ctf_str_atoms, str);   /* Existing atoms get refs added only if they are provisional:     non-provisional strings already have a fixed strtab offset, and just     get their ref updated immediately, since its value cannot change.  */   if (atom)    {      if (!ctf_dynhash_lookup (fp->ctf_prov_strtab, (void *) (uintptr_t)			       atom->csa_offset))	{	  if (flags & CTF_STR_ADD_REF)	    {	      if (atom->csa_external_offset)		*ref = atom->csa_external_offset;	      else		*ref = atom->csa_offset;	    }	  return atom;	}       if (flags & CTF_STR_ADD_REF)	{	  if (!aref_create (fp, atom, ref, flags))	    {	      ctf_set_errno (fp, ENOMEM);	      return NULL;	    }	}       return atom;    }   /* New atom.  */   if ((atom = malloc (sizeof (struct ctf_str_atom))) == NULL)    goto oom;  memset (atom, 0, sizeof (struct ctf_str_atom));   /* Don't allocate new strings if this string is within an mmapped     strtab.  */   if ((unsigned char *) str < (unsigned char *) fp->ctf_data_mmapped      || (unsigned char *) str > (unsigned char *) fp->ctf_data_mmapped + fp->ctf_data_mmapped_len)    {      if ((newstr = strdup (str)) == NULL)	goto oom;      atom->csa_flags |= CTF_STR_ATOM_FREEABLE;      atom->csa_str = newstr;    }  else    atom->csa_str = (char *) str;   if (ctf_dynhash_insert (fp->ctf_str_atoms, atom->csa_str, atom) < 0)    goto oom;  added = 1;   atom->csa_snapshot_id = fp->ctf_snapshots;   /* New atoms marked provisional go into the provisional strtab, and get a     ref added.  */   if (flags & CTF_STR_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 (flags & CTF_STR_ADD_REF)      {	if (!aref_create (fp, atom, ref, flags))	  goto oom;      }    }   return atom;  oom:  if (added)    ctf_dynhash_remove (fp->ctf_str_atoms, atom->csa_str);  free (atom);  free (newstr);  ctf_set_errno (fp, ENOMEM);  return NULL;} /* 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_tctf_str_add (ctf_dict_t *fp, const char *str){  ctf_str_atom_t *atom;   if (!str)    str = "";   atom = ctf_str_add_ref_internal (fp, str, CTF_STR_PROVISIONAL, 0);  if (!atom)    return 0;   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).  */uint32_tctf_str_add_ref (ctf_dict_t *fp, const char *str, uint32_t *ref){  ctf_str_atom_t *atom;   if (!str)    str = "";   atom = ctf_str_add_ref_internal (fp, str, CTF_STR_ADD_REF				   | CTF_STR_PROVISIONAL, ref);  if (!atom)    return 0;   return atom->csa_offset;} /* Like ctf_str_add_ref(), but note that the ref may be moved later on.  */uint32_tctf_str_add_movable_ref (ctf_dict_t *fp, const char *str, uint32_t *ref){  ctf_str_atom_t *atom;   if (!str)    str = "";   atom = ctf_str_add_ref_internal (fp, str, CTF_STR_ADD_REF				   | CTF_STR_PROVISIONAL				   | CTF_STR_MOVABLE, ref);  if (!atom)    return 0;   return atom->csa_offset;} /* Add an external strtab reference at OFFSET.  Returns zero if the addition   failed, nonzero otherwise.  */intctf_str_add_external (ctf_dict_t *fp, const char *str, uint32_t offset){  ctf_str_atom_t *atom;   if (!str)    str = "";   atom = ctf_str_add_ref_internal (fp, str, 0, 0);  if (!atom)    return 0;   atom->csa_external_offset = CTF_SET_STID (offset, CTF_STRTAB_1);   if (!fp->ctf_syn_ext_strtab)    fp->ctf_syn_ext_strtab = ctf_dynhash_create (ctf_hash_integer,						 ctf_hash_eq_integer,						 NULL, NULL);  if (!fp->ctf_syn_ext_strtab)    {      ctf_set_errno (fp, ENOMEM);      return 0;    }   if (ctf_dynhash_insert (fp->ctf_syn_ext_strtab,			  (void *) (uintptr_t)			  atom->csa_external_offset,			  (void *) atom->csa_str) < 0)    {      /* No need to bother freeing the syn_ext_strtab: it will get freed at	 ctf_str_write_strtab time if unreferenced.  */      ctf_set_errno (fp, ENOMEM);      return 0;    }   return 1;} /* Note that refs have moved from (SRC, LEN) to DEST.  We use the movable   refs backpointer for this, because it is done an amortized-constant   number of times during structure member and enumerand addition, and if we   did a linear search this would turn such addition into an O(n^2)   operation.  Even this is not linear, but it's better than that.  */intctf_str_move_refs (ctf_dict_t *fp, void *src, size_t len, void *dest){  uintptr_t p;   if (src == dest)    return 0;   for (p = (uintptr_t) src; p - (uintptr_t) src < len; p++)    {      ctf_str_atom_ref_movable_t *ref;       if ((ref = ctf_dynhash_lookup (fp->ctf_str_movable_refs,

Lines 1–500 of 829. Load more