libctf/ctf-serialize.c

   1 /* CTF dict creation.
   2    Copyright (C) 2019-2022 Free Software Foundation, Inc.
   3
   4    This file is part of libctf.
   5
   6    libctf is free software; you can redistribute it and/or modify it under
   7    the terms of the GNU General Public License as published by the Free
   8    Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14    See the GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; see the file COPYING.  If not see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <ctf-impl.h>
  21 #include <assert.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <zlib.h>
  25
  26 #include <elf.h>
  27 #include "elf-bfd.h"
  28
  29 /* Symtypetab sections.  */
  30
  31 /* Symtypetab emission flags.  */
  32
  33 #define CTF_SYMTYPETAB_EMIT_FUNCTION 0x1
  34 #define CTF_SYMTYPETAB_EMIT_PAD 0x2
  35 #define CTF_SYMTYPETAB_FORCE_INDEXED 0x4
  36
  37 /* Properties of symtypetab emission, shared by symtypetab section
  38    sizing and symtypetab emission itself.  */
  39
  40 typedef struct emit_symtypetab_state
  41 {
  42   /* True if linker-reported symbols are being filtered out.  symfp is set if
  43      this is true: otherwise, indexing is forced and the symflags indicate as
  44      much. */
  45   int filter_syms;
  46
  47   /* True if symbols are being sorted.  */
  48   int sort_syms;
  49
  50   /* Flags for symtypetab emission.  */
  51   int symflags;
  52
  53   /* The dict to which the linker has reported symbols.  */
  54   ctf_dict_t *symfp;
  55
  56   /* The maximum number of objects seen.  */
  57   size_t maxobjt;
  58
  59   /* The maximum number of func info entris seen.  */
  60   size_t maxfunc;
  61 } emit_symtypetab_state_t;
  62
  63 /* Determine if a symbol is "skippable" and should never appear in the
  64    symtypetab sections.  */
  65
  66 int
  67 ctf_symtab_skippable (ctf_link_sym_t *sym)
  68 {
  69   /* Never skip symbols whose name is not yet known.  */
  70   if (sym->st_nameidx_set)
  71     return 0;
  72
  73   return (sym->st_name == NULL || sym->st_name[0] == 0
  74           || sym->st_shndx == SHN_UNDEF
  75           || strcmp (sym->st_name, "_START_") == 0
  76           || strcmp (sym->st_name, "_END_") == 0
  77           || (sym->st_type == STT_OBJECT && sym->st_shndx == SHN_EXTABS
  78               && sym->st_value == 0));
  79 }
  80
  81 /* Get the number of symbols in a symbol hash, the count of symbols, the maximum
  82    seen, the eventual size, without any padding elements, of the func/data and
  83    (if generated) index sections, and the size of accumulated padding elements.
  84    The linker-reported set of symbols is found in SYMFP: it may be NULL if
  85    symbol filtering is not desired, in which case CTF_SYMTYPETAB_FORCE_INDEXED
  86    will always be set in the flags.
  87
  88    Also figure out if any symbols need to be moved to the variable section, and
  89    add them (if not already present).  */
  90
  91 _libctf_nonnull_ ((1,3,4,5,6,7,8))
  92 static int
  93 symtypetab_density (ctf_dict_t *fp, ctf_dict_t *symfp, ctf_dynhash_t *symhash,
  94                     size_t *count, size_t *max, size_t *unpadsize,
  95                     size_t *padsize, size_t *idxsize, int flags)
  96 {
  97   ctf_next_t *i = NULL;
  98   const void *name;
  99   const void *ctf_sym;
 100   ctf_dynhash_t *linker_known = NULL;
 101   int err;
 102   int beyond_max = 0;
 103
 104   *count = 0;
 105   *max = 0;
 106   *unpadsize = 0;
 107   *idxsize = 0;
 108   *padsize = 0;
 109
 110   if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 111     {
 112       /* Make a dynhash citing only symbols reported by the linker of the
 113          appropriate type, then traverse all potential-symbols we know the types
 114          of, removing them from linker_known as we go.  Once this is done, the
 115          only symbols remaining in linker_known are symbols we don't know the
 116          types of: we must emit pads for those symbols that are below the
 117          maximum symbol we will emit (any beyond that are simply skipped).
 118
 119          If there are none, this symtypetab will be empty: just report that.  */
 120
 121       if (!symfp->ctf_dynsyms)
 122         return 0;
 123
 124       if ((linker_known = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
 125                                               NULL, NULL)) == NULL)
 126         return (ctf_set_errno (fp, ENOMEM));
 127
 128       while ((err = ctf_dynhash_cnext (symfp->ctf_dynsyms, &i,
 129                                        &name, &ctf_sym)) == 0)
 130         {
 131           ctf_link_sym_t *sym = (ctf_link_sym_t *) ctf_sym;
 132
 133           if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 134                && sym->st_type != STT_FUNC)
 135               || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 136                   && sym->st_type != STT_OBJECT))
 137             continue;
 138
 139           if (ctf_symtab_skippable (sym))
 140             continue;
 141
 142           /* This should only be true briefly before all the names are
 143              finalized, long before we get this far.  */
 144           if (!ctf_assert (fp, !sym->st_nameidx_set))
 145             return -1;                          /* errno is set for us.  */
 146
 147           if (ctf_dynhash_cinsert (linker_known, name, ctf_sym) < 0)
 148             {
 149               ctf_dynhash_destroy (linker_known);
 150               return (ctf_set_errno (fp, ENOMEM));
 151             }
 152         }
 153       if (err != ECTF_NEXT_END)
 154         {
 155           ctf_err_warn (fp, 0, err, _("iterating over linker-known symbols during "
 156                                   "serialization"));
 157           ctf_dynhash_destroy (linker_known);
 158           return (ctf_set_errno (fp, err));
 159         }
 160     }
 161
 162   while ((err = ctf_dynhash_cnext (symhash, &i, &name, NULL)) == 0)
 163     {
 164       ctf_link_sym_t *sym;
 165
 166       if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 167         {
 168           /* Linker did not report symbol in symtab.  Remove it from the
 169              set of known data symbols and continue.  */
 170           if ((sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, name)) == NULL)
 171             {
 172               ctf_dynhash_remove (symhash, name);
 173               continue;
 174             }
 175
 176           /* We don't remove skippable symbols from the symhash because we don't
 177              want them to be migrated into variables.  */
 178           if (ctf_symtab_skippable (sym))
 179             continue;
 180
 181           if ((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 182               && sym->st_type != STT_FUNC)
 183             {
 184               ctf_err_warn (fp, 1, 0, _("symbol %s (%x) added to CTF as a "
 185                                         "function but is of type %x.  "
 186                                         "The symbol type lookup tables "
 187                                         "are probably corrupted"),
 188                             sym->st_name, sym->st_symidx, sym->st_type);
 189               ctf_dynhash_remove (symhash, name);
 190               continue;
 191             }
 192           else if (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 193                    && sym->st_type != STT_OBJECT)
 194             {
 195               ctf_err_warn (fp, 1, 0, _("symbol %s (%x) added to CTF as a "
 196                                         "data object but is of type %x.  "
 197                                         "The symbol type lookup tables "
 198                                         "are probably corrupted"),
 199                             sym->st_name, sym->st_symidx, sym->st_type);
 200               ctf_dynhash_remove (symhash, name);
 201               continue;
 202             }
 203
 204           ctf_dynhash_remove (linker_known, name);
 205         }
 206       *unpadsize += sizeof (uint32_t);
 207       (*count)++;
 208
 209       if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 210         {
 211           if (*max < sym->st_symidx)
 212             *max = sym->st_symidx;
 213         }
 214       else
 215         (*max)++;
 216     }
 217   if (err != ECTF_NEXT_END)
 218     {
 219       ctf_err_warn (fp, 0, err, _("iterating over CTF symtypetab during "
 220                                   "serialization"));
 221       ctf_dynhash_destroy (linker_known);
 222       return (ctf_set_errno (fp, err));
 223     }
 224
 225   if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 226     {
 227       while ((err = ctf_dynhash_cnext (linker_known, &i, NULL, &ctf_sym)) == 0)
 228         {
 229           ctf_link_sym_t *sym = (ctf_link_sym_t *) ctf_sym;
 230
 231           if (sym->st_symidx > *max)
 232             beyond_max++;
 233         }
 234       if (err != ECTF_NEXT_END)
 235         {
 236           ctf_err_warn (fp, 0, err, _("iterating over linker-known symbols "
 237                                       "during CTF serialization"));
 238           ctf_dynhash_destroy (linker_known);
 239           return (ctf_set_errno (fp, err));
 240         }
 241     }
 242
 243   *idxsize = *count * sizeof (uint32_t);
 244   if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 245     *padsize = (ctf_dynhash_elements (linker_known) - beyond_max) * sizeof (uint32_t);
 246
 247   ctf_dynhash_destroy (linker_known);
 248   return 0;
 249 }
 250
 251 /* Emit an objt or func symtypetab into DP in a particular order defined by an
 252    array of ctf_link_sym_t or symbol names passed in.  The index has NIDX
 253    elements in it: unindexed output would terminate at symbol OUTMAX and is in
 254    any case no larger than SIZE bytes.  Some index elements are expected to be
 255    skipped: see symtypetab_density.  The linker-reported set of symbols (if any)
 256    is found in SYMFP. */
 257 static int
 258 emit_symtypetab (ctf_dict_t *fp, ctf_dict_t *symfp, uint32_t *dp,
 259                  ctf_link_sym_t **idx, const char **nameidx, uint32_t nidx,
 260                  uint32_t outmax, int size, int flags)
 261 {
 262   uint32_t i;
 263   uint32_t *dpp = dp;
 264   ctf_dynhash_t *symhash;
 265
 266   ctf_dprintf ("Emitting table of size %i, outmax %u, %u symtypetab entries, "
 267                "flags %i\n", size, outmax, nidx, flags);
 268
 269   /* Empty table? Nothing to do.  */
 270   if (size == 0)
 271     return 0;
 272
 273   if (flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 274     symhash = fp->ctf_funchash;
 275   else
 276     symhash = fp->ctf_objthash;
 277
 278   for (i = 0; i < nidx; i++)
 279     {
 280       const char *sym_name;
 281       void *type;
 282
 283       /* If we have a linker-reported set of symbols, we may be given that set
 284          to work from, or a set of symbol names.  In both cases we want to look
 285          at the corresponding linker-reported symbol (if any).  */
 286       if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 287         {
 288           ctf_link_sym_t *this_link_sym;
 289
 290           if (idx)
 291             this_link_sym = idx[i];
 292           else
 293             this_link_sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, nameidx[i]);
 294
 295           /* Unreported symbol number.  No pad, no nothing.  */
 296           if (!this_link_sym)
 297             continue;
 298
 299           /* Symbol of the wrong type, or skippable?  This symbol is not in this
 300              table.  */
 301           if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 302                && this_link_sym->st_type != STT_FUNC)
 303               || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 304                   && this_link_sym->st_type != STT_OBJECT))
 305             continue;
 306
 307           if (ctf_symtab_skippable (this_link_sym))
 308             continue;
 309
 310           sym_name = this_link_sym->st_name;
 311
 312           /* Linker reports symbol of a different type to the symbol we actually
 313              added?  Skip the symbol.  No pad, since the symbol doesn't actually
 314              belong in this table at all.  (Warned about in
 315              symtypetab_density.)  */
 316           if ((this_link_sym->st_type == STT_FUNC)
 317               && (ctf_dynhash_lookup (fp->ctf_objthash, sym_name)))
 318             continue;
 319
 320           if ((this_link_sym->st_type == STT_OBJECT)
 321               && (ctf_dynhash_lookup (fp->ctf_funchash, sym_name)))
 322             continue;
 323         }
 324       else
 325         sym_name = nameidx[i];
 326
 327       /* Symbol in index but no type set? Silently skip and (optionally)
 328          pad.  (In force-indexed mode, this is also where we track symbols of
 329          the wrong type for this round of insertion.)  */
 330       if ((type = ctf_dynhash_lookup (symhash, sym_name)) == NULL)
 331         {
 332           if (flags & CTF_SYMTYPETAB_EMIT_PAD)
 333             *dpp++ = 0;
 334           continue;
 335         }
 336
 337       if (!ctf_assert (fp, (((char *) dpp) - (char *) dp) < size))
 338         return -1;                              /* errno is set for us.  */
 339
 340       *dpp++ = (ctf_id_t) (uintptr_t) type;
 341
 342       /* When emitting unindexed output, all later symbols are pads: stop
 343          early.  */
 344       if ((flags & CTF_SYMTYPETAB_EMIT_PAD) && idx[i]->st_symidx == outmax)
 345         break;
 346     }
 347
 348   return 0;
 349 }
 350
 351 /* Emit an objt or func symtypetab index into DP in a paticular order defined by
 352    an array of symbol names passed in.  Stop at NIDX.  The linker-reported set
 353    of symbols (if any) is found in SYMFP. */
 354 static int
 355 emit_symtypetab_index (ctf_dict_t *fp, ctf_dict_t *symfp, uint32_t *dp,
 356                        const char **idx, uint32_t nidx, int size, int flags)
 357 {
 358   uint32_t i;
 359   uint32_t *dpp = dp;
 360   ctf_dynhash_t *symhash;
 361
 362   ctf_dprintf ("Emitting index of size %i, %u entries reported by linker, "
 363                "flags %i\n", size, nidx, flags);
 364
 365   /* Empty table? Nothing to do.  */
 366   if (size == 0)
 367     return 0;
 368
 369   if (flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 370     symhash = fp->ctf_funchash;
 371   else
 372     symhash = fp->ctf_objthash;
 373
 374   /* Indexes should always be unpadded.  */
 375   if (!ctf_assert (fp, !(flags & CTF_SYMTYPETAB_EMIT_PAD)))
 376     return -1;                                  /* errno is set for us.  */
 377
 378   for (i = 0; i < nidx; i++)
 379     {
 380       const char *sym_name;
 381       void *type;
 382
 383       if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
 384         {
 385           ctf_link_sym_t *this_link_sym;
 386
 387           this_link_sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, idx[i]);
 388
 389           /* This is an index: unreported symbols should never appear in it.  */
 390           if (!ctf_assert (fp, this_link_sym != NULL))
 391             return -1;                          /* errno is set for us.  */
 392
 393           /* Symbol of the wrong type, or skippable?  This symbol is not in this
 394              table.  */
 395           if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 396                && this_link_sym->st_type != STT_FUNC)
 397               || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
 398                   && this_link_sym->st_type != STT_OBJECT))
 399             continue;
 400
 401           if (ctf_symtab_skippable (this_link_sym))
 402             continue;
 403
 404           sym_name = this_link_sym->st_name;
 405
 406           /* Linker reports symbol of a different type to the symbol we actually
 407              added?  Skip the symbol.  */
 408           if ((this_link_sym->st_type == STT_FUNC)
 409               && (ctf_dynhash_lookup (fp->ctf_objthash, sym_name)))
 410             continue;
 411
 412           if ((this_link_sym->st_type == STT_OBJECT)
 413               && (ctf_dynhash_lookup (fp->ctf_funchash, sym_name)))
 414             continue;
 415         }
 416       else
 417         sym_name = idx[i];
 418
 419       /* Symbol in index and reported by linker, but no type set? Silently skip
 420          and (optionally) pad.  (In force-indexed mode, this is also where we
 421          track symbols of the wrong type for this round of insertion.)  */
 422       if ((type = ctf_dynhash_lookup (symhash, sym_name)) == NULL)
 423         continue;
 424
 425       ctf_str_add_ref (fp, sym_name, dpp++);
 426
 427       if (!ctf_assert (fp, (((char *) dpp) - (char *) dp) <= size))
 428         return -1;                              /* errno is set for us.  */
 429     }
 430
 431   return 0;
 432 }
 433
 434 /* Delete symbols that have been assigned names from the variable section.  Must
 435    be called from within ctf_serialize, because that is the only place you can
 436    safely delete variables without messing up ctf_rollback.  */
 437
 438 static int
 439 symtypetab_delete_nonstatics (ctf_dict_t *fp, ctf_dict_t *symfp)
 440 {
 441   ctf_dvdef_t *dvd, *nvd;
 442   ctf_id_t type;
 443
 444   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
 445     {
 446       nvd = ctf_list_next (dvd);
 447
 448       if ((((type = (ctf_id_t) (uintptr_t)
 449              ctf_dynhash_lookup (fp->ctf_objthash, dvd->dvd_name)) > 0)
 450            || (type = (ctf_id_t) (uintptr_t)
 451                ctf_dynhash_lookup (fp->ctf_funchash, dvd->dvd_name)) > 0)
 452           && ctf_dynhash_lookup (symfp->ctf_dynsyms, dvd->dvd_name) != NULL
 453           && type == dvd->dvd_type)
 454         ctf_dvd_delete (fp, dvd);
 455     }
 456
 457   return 0;
 458 }
 459
 460 /* Figure out the sizes of the symtypetab sections, their indexed state,
 461    etc.  */
 462 static int
 463 ctf_symtypetab_sect_sizes (ctf_dict_t *fp, emit_symtypetab_state_t *s,
 464                            ctf_header_t *hdr, size_t *objt_size,
 465                            size_t *func_size, size_t *objtidx_size,
 466                            size_t *funcidx_size)
 467 {
 468   size_t nfuncs, nobjts;
 469   size_t objt_unpadsize, func_unpadsize, objt_padsize, func_padsize;
 470
 471   /* If doing a writeout as part of linking, and the link flags request it,
 472      filter out reported symbols from the variable section, and filter out all
 473      other symbols from the symtypetab sections.  (If we are not linking, the
 474      symbols are sorted; if we are linking, don't bother sorting if we are not
 475      filtering out reported symbols: this is almost certaily an ld -r and only
 476      the linker is likely to consume these symtypetabs again.  The linker
 477      doesn't care what order the symtypetab entries is in, since it only
 478      iterates over symbols and does not use the ctf_lookup_by_symbol* API.)  */
 479
 480   s->sort_syms = 1;
 481   if (fp->ctf_flags & LCTF_LINKING)
 482     {
 483       s->filter_syms = !(fp->ctf_link_flags & CTF_LINK_NO_FILTER_REPORTED_SYMS);
 484       if (!s->filter_syms)
 485         s->sort_syms = 0;
 486     }
 487
 488   /* Find the dict to which the linker has reported symbols, if any.  */
 489
 490   if (s->filter_syms)
 491     {
 492       if (!fp->ctf_dynsyms && fp->ctf_parent && fp->ctf_parent->ctf_dynsyms)
 493         s->symfp = fp->ctf_parent;
 494       else
 495         s->symfp = fp;
 496     }
 497
 498   /* If not filtering, keep all potential symbols in an unsorted, indexed
 499      dict.  */
 500   if (!s->filter_syms)
 501     s->symflags = CTF_SYMTYPETAB_FORCE_INDEXED;
 502   else
 503     hdr->cth_flags |= CTF_F_IDXSORTED;
 504
 505   if (!ctf_assert (fp, (s->filter_syms && s->symfp)
 506                    || (!s->filter_syms && !s->symfp
 507                        && ((s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED) != 0))))
 508     return -1;
 509
 510   /* Work out the sizes of the object and function sections, and work out the
 511      number of pad (unassigned) symbols in each, and the overall size of the
 512      sections.  */
 513
 514   if (symtypetab_density (fp, s->symfp, fp->ctf_objthash, &nobjts, &s->maxobjt,
 515                           &objt_unpadsize, &objt_padsize, objtidx_size,
 516                           s->symflags) < 0)
 517     return -1;                                  /* errno is set for us.  */
 518
 519   ctf_dprintf ("Object symtypetab: %i objects, max %i, unpadded size %i, "
 520                "%i bytes of pads, index size %i\n", (int) nobjts,
 521                (int) s->maxobjt, (int) objt_unpadsize, (int) objt_padsize,
 522                (int) *objtidx_size);
 523
 524   if (symtypetab_density (fp, s->symfp, fp->ctf_funchash, &nfuncs, &s->maxfunc,
 525                           &func_unpadsize, &func_padsize, funcidx_size,
 526                           s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 527     return -1;                                  /* errno is set for us.  */
 528
 529   ctf_dprintf ("Function symtypetab: %i functions, max %i, unpadded size %i, "
 530                "%i bytes of pads, index size %i\n", (int) nfuncs,
 531                (int) s->maxfunc, (int) func_unpadsize, (int) func_padsize,
 532                (int) *funcidx_size);
 533
 534   /* It is worth indexing each section if it would save space to do so, due to
 535      reducing the number of pads sufficiently.  A pad is the same size as a
 536      single index entry: but index sections compress relatively poorly compared
 537      to constant pads, so it takes a lot of contiguous padding to equal one
 538      index section entry.  It would be nice to be able to *verify* whether we
 539      would save space after compression rather than guessing, but this seems
 540      difficult, since it would require complete reserialization.  Regardless, if
 541      the linker has not reported any symbols (e.g. if this is not a final link
 542      but just an ld -r), we must emit things in indexed fashion just as the
 543      compiler does.  */
 544
 545   *objt_size = objt_unpadsize;
 546   if (!(s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
 547       && ((objt_padsize + objt_unpadsize) * CTF_INDEX_PAD_THRESHOLD
 548           > objt_padsize))
 549     {
 550       *objt_size += objt_padsize;
 551       *objtidx_size = 0;
 552     }
 553
 554   *func_size = func_unpadsize;
 555   if (!(s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
 556       && ((func_padsize + func_unpadsize) * CTF_INDEX_PAD_THRESHOLD
 557           > func_padsize))
 558     {
 559       *func_size += func_padsize;
 560       *funcidx_size = 0;
 561     }
 562
 563   /* If we are filtering symbols out, those symbols that the linker has not
 564      reported have now been removed from the ctf_objthash and ctf_funchash.
 565      Delete entries from the variable section that duplicate newly-added
 566      symbols.  There's no need to migrate new ones in: we do that (if necessary)
 567      in ctf_link_deduplicating_variables.  */
 568
 569   if (s->filter_syms && s->symfp->ctf_dynsyms &&
 570       symtypetab_delete_nonstatics (fp, s->symfp) < 0)
 571     return -1;
 572
 573   return 0;
 574 }
 575
 576 static int
 577 ctf_emit_symtypetab_sects (ctf_dict_t *fp, emit_symtypetab_state_t *s,
 578                            unsigned char **tptr, size_t objt_size,
 579                            size_t func_size, size_t objtidx_size,
 580                            size_t funcidx_size)
 581 {
 582   unsigned char *t = *tptr;
 583   size_t nsymtypes = 0;
 584   const char **sym_name_order = NULL;
 585   int err;
 586
 587   /* Sort the linker's symbols into name order if need be.  */
 588
 589   if ((objtidx_size != 0) || (funcidx_size != 0))
 590     {
 591       ctf_next_t *i = NULL;
 592       void *symname;
 593       const char **walk;
 594
 595       if (s->filter_syms)
 596         {
 597           if (s->symfp->ctf_dynsyms)
 598             nsymtypes = ctf_dynhash_elements (s->symfp->ctf_dynsyms);
 599           else
 600             nsymtypes = 0;
 601         }
 602       else
 603         nsymtypes = ctf_dynhash_elements (fp->ctf_objthash)
 604           + ctf_dynhash_elements (fp->ctf_funchash);
 605
 606       if ((sym_name_order = calloc (nsymtypes, sizeof (const char *))) == NULL)
 607         goto oom;
 608
 609       walk = sym_name_order;
 610
 611       if (s->filter_syms)
 612         {
 613           if (s->symfp->ctf_dynsyms)
 614             {
 615               while ((err = ctf_dynhash_next_sorted (s->symfp->ctf_dynsyms, &i,
 616                                                      &symname, NULL,
 617                                                      ctf_dynhash_sort_by_name,
 618                                                      NULL)) == 0)
 619                 *walk++ = (const char *) symname;
 620               if (err != ECTF_NEXT_END)
 621                 goto symerr;
 622             }
 623         }
 624       else
 625         {
 626           ctf_hash_sort_f sort_fun = NULL;
 627
 628           /* Since we partition the set of symbols back into objt and func,
 629              we can sort the two independently without harm.  */
 630           if (s->sort_syms)
 631             sort_fun = ctf_dynhash_sort_by_name;
 632
 633           while ((err = ctf_dynhash_next_sorted (fp->ctf_objthash, &i, &symname,
 634                                                  NULL, sort_fun, NULL)) == 0)
 635             *walk++ = (const char *) symname;
 636           if (err != ECTF_NEXT_END)
 637             goto symerr;
 638
 639           while ((err = ctf_dynhash_next_sorted (fp->ctf_funchash, &i, &symname,
 640                                                  NULL, sort_fun, NULL)) == 0)
 641             *walk++ = (const char *) symname;
 642           if (err != ECTF_NEXT_END)
 643             goto symerr;
 644         }
 645     }
 646
 647   /* Emit the object and function sections, and if necessary their indexes.
 648      Emission is done in symtab order if there is no index, and in index
 649      (name) order otherwise.  */
 650
 651   if ((objtidx_size == 0) && s->symfp && s->symfp->ctf_dynsymidx)
 652     {
 653       ctf_dprintf ("Emitting unindexed objt symtypetab\n");
 654       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t,
 655                            s->symfp->ctf_dynsymidx, NULL,
 656                            s->symfp->ctf_dynsymmax + 1, s->maxobjt,
 657                            objt_size, s->symflags | CTF_SYMTYPETAB_EMIT_PAD) < 0)
 658         goto err;                               /* errno is set for us.  */
 659     }
 660   else
 661     {
 662       ctf_dprintf ("Emitting indexed objt symtypetab\n");
 663       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t, NULL,
 664                            sym_name_order, nsymtypes, s->maxobjt,
 665                            objt_size, s->symflags) < 0)
 666         goto err;                               /* errno is set for us.  */
 667     }
 668
 669   t += objt_size;
 670
 671   if ((funcidx_size == 0) && s->symfp && s->symfp->ctf_dynsymidx)
 672     {
 673       ctf_dprintf ("Emitting unindexed func symtypetab\n");
 674       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t,
 675                            s->symfp->ctf_dynsymidx, NULL,
 676                            s->symfp->ctf_dynsymmax + 1, s->maxfunc,
 677                            func_size, s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION
 678                            | CTF_SYMTYPETAB_EMIT_PAD) < 0)
 679         goto err;                               /* errno is set for us.  */
 680     }
 681   else
 682     {
 683       ctf_dprintf ("Emitting indexed func symtypetab\n");
 684       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t, NULL, sym_name_order,
 685                            nsymtypes, s->maxfunc, func_size,
 686                            s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 687         goto err;                               /* errno is set for us.  */
 688     }
 689
 690   t += func_size;
 691
 692   if (objtidx_size > 0)
 693     if (emit_symtypetab_index (fp, s->symfp, (uint32_t *) t, sym_name_order,
 694                                nsymtypes, objtidx_size, s->symflags) < 0)
 695       goto err;
 696
 697   t += objtidx_size;
 698
 699   if (funcidx_size > 0)
 700     if (emit_symtypetab_index (fp, s->symfp, (uint32_t *) t, sym_name_order,
 701                                nsymtypes, funcidx_size,
 702                                s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 703       goto err;
 704
 705   t += funcidx_size;
 706   free (sym_name_order);
 707   *tptr = t;
 708
 709   return 0;
 710
 711  oom:
 712   ctf_set_errno (fp, EAGAIN);
 713   goto err;
 714 symerr:
 715   ctf_err_warn (fp, 0, err, _("error serializing symtypetabs"));
 716  err:
 717   free (sym_name_order);
 718   return -1;
 719 }
 720
 721 /* Type section.  */
 722
 723 /* Iterate through the dynamic type definition list and compute the
 724    size of the CTF type section.  */
 725
 726 static size_t
 727 ctf_type_sect_size (ctf_dict_t *fp)
 728 {
 729   ctf_dtdef_t *dtd;
 730   size_t type_size;
 731
 732   for (type_size = 0, dtd = ctf_list_next (&fp->ctf_dtdefs);
 733        dtd != NULL; dtd = ctf_list_next (dtd))
 734     {
 735       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 736       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 737       size_t type_ctt_size = dtd->dtd_data.ctt_size;
 738
 739       /* Shrink ctf_type_t-using types from a ctf_type_t to a ctf_stype_t
 740          if possible.  */
 741
 742       if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
 743         {
 744           size_t lsize = CTF_TYPE_LSIZE (&dtd->dtd_data);
 745
 746           if (lsize <= CTF_MAX_SIZE)
 747             type_ctt_size = lsize;
 748         }
 749
 750       if (type_ctt_size != CTF_LSIZE_SENT)
 751         type_size += sizeof (ctf_stype_t);
 752       else
 753         type_size += sizeof (ctf_type_t);
 754
 755       switch (kind)
 756         {
 757         case CTF_K_INTEGER:
 758         case CTF_K_FLOAT:
 759           type_size += sizeof (uint32_t);
 760           break;
 761         case CTF_K_ARRAY:
 762           type_size += sizeof (ctf_array_t);
 763           break;
 764         case CTF_K_SLICE:
 765           type_size += sizeof (ctf_slice_t);
 766           break;
 767         case CTF_K_FUNCTION:
 768           type_size += sizeof (uint32_t) * (vlen + (vlen & 1));
 769           break;
 770         case CTF_K_STRUCT:
 771         case CTF_K_UNION:
 772           if (type_ctt_size < CTF_LSTRUCT_THRESH)
 773             type_size += sizeof (ctf_member_t) * vlen;
 774           else
 775             type_size += sizeof (ctf_lmember_t) * vlen;
 776           break;
 777         case CTF_K_ENUM:
 778           type_size += sizeof (ctf_enum_t) * vlen;
 779           break;
 780         }
 781     }
 782
 783   return type_size;
 784 }
 785
 786 /* Take a final lap through the dynamic type definition list and copy the
 787    appropriate type records to the output buffer, noting down the strings as
 788    we go.  */
 789
 790 static void
 791 ctf_emit_type_sect (ctf_dict_t *fp, unsigned char **tptr)
 792 {
 793   unsigned char *t = *tptr;
 794   ctf_dtdef_t *dtd;
 795
 796   for (dtd = ctf_list_next (&fp->ctf_dtdefs);
 797        dtd != NULL; dtd = ctf_list_next (dtd))
 798     {
 799       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 800       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 801       size_t type_ctt_size = dtd->dtd_data.ctt_size;
 802       size_t len;
 803       ctf_stype_t *copied;
 804       const char *name;
 805       size_t i;
 806
 807       /* Shrink ctf_type_t-using types from a ctf_type_t to a ctf_stype_t
 808          if possible.  */
 809
 810       if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
 811         {
 812           size_t lsize = CTF_TYPE_LSIZE (&dtd->dtd_data);
 813
 814           if (lsize <= CTF_MAX_SIZE)
 815             type_ctt_size = lsize;
 816         }
 817
 818       if (type_ctt_size != CTF_LSIZE_SENT)
 819         len = sizeof (ctf_stype_t);
 820       else
 821         len = sizeof (ctf_type_t);
 822
 823       memcpy (t, &dtd->dtd_data, len);
 824       copied = (ctf_stype_t *) t;  /* name is at the start: constant offset.  */
 825       if (copied->ctt_name
 826           && (name = ctf_strraw (fp, copied->ctt_name)) != NULL)
 827         {
 828           ctf_str_add_ref (fp, name, &copied->ctt_name);
 829           ctf_str_add_ref (fp, name, &dtd->dtd_data.ctt_name);
 830         }
 831       copied->ctt_size = type_ctt_size;
 832       t += len;
 833
 834       switch (kind)
 835         {
 836         case CTF_K_INTEGER:
 837         case CTF_K_FLOAT:
 838           memcpy (t, dtd->dtd_vlen, sizeof (uint32_t));
 839           t += sizeof (uint32_t);
 840           break;
 841
 842         case CTF_K_SLICE:
 843           memcpy (t, dtd->dtd_vlen, sizeof (struct ctf_slice));
 844           t += sizeof (struct ctf_slice);
 845           break;
 846
 847         case CTF_K_ARRAY:
 848           memcpy (t, dtd->dtd_vlen, sizeof (struct ctf_array));
 849           t += sizeof (struct ctf_array);
 850           break;
 851
 852         case CTF_K_FUNCTION:
 853           /* Functions with no args also have no vlen.  */
 854           if (dtd->dtd_vlen)
 855             memcpy (t, dtd->dtd_vlen, sizeof (uint32_t) * (vlen + (vlen & 1)));
 856           t += sizeof (uint32_t) * (vlen + (vlen & 1));
 857           break;
 858
 859           /* These need to be copied across element by element, depending on
 860              their ctt_size.  */
 861         case CTF_K_STRUCT:
 862         case CTF_K_UNION:
 863           {
 864             ctf_lmember_t *dtd_vlen = (ctf_lmember_t *) dtd->dtd_vlen;
 865             ctf_lmember_t *t_lvlen = (ctf_lmember_t *) t;
 866             ctf_member_t *t_vlen = (ctf_member_t *) t;
 867
 868             for (i = 0; i < vlen; i++)
 869               {
 870                 const char *name = ctf_strraw (fp, dtd_vlen[i].ctlm_name);
 871
 872                 ctf_str_add_ref (fp, name, &dtd_vlen[i].ctlm_name);
 873
 874                 if (type_ctt_size < CTF_LSTRUCT_THRESH)
 875                   {
 876                     t_vlen[i].ctm_name = dtd_vlen[i].ctlm_name;
 877                     t_vlen[i].ctm_type = dtd_vlen[i].ctlm_type;
 878                     t_vlen[i].ctm_offset = CTF_LMEM_OFFSET (&dtd_vlen[i]);
 879                     ctf_str_add_ref (fp, name, &t_vlen[i].ctm_name);
 880                   }
 881                 else
 882                   {
 883                     t_lvlen[i] = dtd_vlen[i];
 884                     ctf_str_add_ref (fp, name, &t_lvlen[i].ctlm_name);
 885                   }
 886               }
 887           }
 888
 889           if (type_ctt_size < CTF_LSTRUCT_THRESH)
 890             t += sizeof (ctf_member_t) * vlen;
 891           else
 892             t += sizeof (ctf_lmember_t) * vlen;
 893           break;
 894
 895         case CTF_K_ENUM:
 896           {
 897             ctf_enum_t *dtd_vlen = (struct ctf_enum *) dtd->dtd_vlen;
 898             ctf_enum_t *t_vlen = (struct ctf_enum *) t;
 899
 900             memcpy (t, dtd->dtd_vlen, sizeof (struct ctf_enum) * vlen);
 901             for (i = 0; i < vlen; i++)
 902               {
 903                 const char *name = ctf_strraw (fp, dtd_vlen[i].cte_name);
 904
 905                 ctf_str_add_ref (fp, name, &t_vlen[i].cte_name);
 906                 ctf_str_add_ref (fp, name, &dtd_vlen[i].cte_name);
 907               }
 908             t += sizeof (struct ctf_enum) * vlen;
 909
 910             break;
 911           }
 912         }
 913     }
 914
 915   *tptr = t;
 916 }
 917
 918 /* Variable section.  */
 919
 920 /* Sort a newly-constructed static variable array.  */
 921
 922 typedef struct ctf_sort_var_arg_cb
 923 {
 924   ctf_dict_t *fp;
 925   ctf_strs_t *strtab;
 926 } ctf_sort_var_arg_cb_t;
 927
 928 static int
 929 ctf_sort_var (const void *one_, const void *two_, void *arg_)
 930 {
 931   const ctf_varent_t *one = one_;
 932   const ctf_varent_t *two = two_;
 933   ctf_sort_var_arg_cb_t *arg = arg_;
 934
 935   return (strcmp (ctf_strraw_explicit (arg->fp, one->ctv_name, arg->strtab),
 936                   ctf_strraw_explicit (arg->fp, two->ctv_name, arg->strtab)));
 937 }
 938
 939 /* Overall serialization.  */
 940
 941 /* If the specified CTF dict is writable and has been modified, reload this dict
 942    with the updated type definitions, ready for serialization.  In order to make
 943    this code and the rest of libctf as simple as possible, we perform updates by
 944    taking the dynamic type definitions and creating an in-memory CTF dict
 945    containing the definitions, and then call ctf_simple_open_internal() on it.
 946    We perform one extra trick here for the benefit of callers and to keep our
 947    code simple: ctf_simple_open_internal() will return a new ctf_dict_t, but we
 948    want to keep the fp constant for the caller, so after
 949    ctf_simple_open_internal() returns, we use memcpy to swap the interior of the
 950    old and new ctf_dict_t's, and then free the old.  */
 951 int
 952 ctf_serialize (ctf_dict_t *fp)
 953 {
 954   ctf_dict_t ofp, *nfp;
 955   ctf_header_t hdr, *hdrp;
 956   ctf_dvdef_t *dvd;
 957   ctf_varent_t *dvarents;
 958   ctf_strs_writable_t strtab;
 959   int err;
 960   int num_missed_str_refs;
 961
 962   unsigned char *t;
 963   unsigned long i;
 964   size_t buf_size, type_size, objt_size, func_size;
 965   size_t funcidx_size, objtidx_size;
 966   size_t nvars;
 967   unsigned char *buf = NULL, *newbuf;
 968
 969   emit_symtypetab_state_t symstate;
 970   memset (&symstate, 0, sizeof (emit_symtypetab_state_t));
 971
 972   if (!(fp->ctf_flags & LCTF_RDWR))
 973     return (ctf_set_errno (fp, ECTF_RDONLY));
 974
 975   /* Update required?  */
 976   if (!(fp->ctf_flags & LCTF_DIRTY))
 977     return 0;
 978
 979   /* The strtab refs table must be empty at this stage.  Any refs already added
 980      will be corrupted by any modifications, including reserialization, after
 981      strtab finalization is complete.  Only this function, and functions it
 982      calls, may add refs, and all memory locations (including in the dtds)
 983      containing strtab offsets must be traversed as part of serialization, and
 984      refs added.  */
 985
 986   if (!ctf_assert (fp, fp->ctf_str_num_refs == 0))
 987     return -1;                                  /* errno is set for us.  */
 988
 989   /* Fill in an initial CTF header.  We will leave the label, object,
 990      and function sections empty and only output a header, type section,
 991      and string table.  The type section begins at a 4-byte aligned
 992      boundary past the CTF header itself (at relative offset zero).  The flag
 993      indicating a new-style function info section (an array of CTF_K_FUNCTION
 994      type IDs in the types section) is flipped on.  */
 995
 996   memset (&hdr, 0, sizeof (hdr));
 997   hdr.cth_magic = CTF_MAGIC;
 998   hdr.cth_version = CTF_VERSION;
 999
1000   /* This is a new-format func info section, and the symtab and strtab come out
1001      of the dynsym and dynstr these days.  */
1002   hdr.cth_flags = (CTF_F_NEWFUNCINFO | CTF_F_DYNSTR);
1003
1004   if (ctf_symtypetab_sect_sizes (fp, &symstate, &hdr, &objt_size, &func_size,
1005                                  &objtidx_size, &funcidx_size) < 0)
1006     return -1;                                  /* errno is set for us.  */
1007
1008   for (nvars = 0, dvd = ctf_list_next (&fp->ctf_dvdefs);
1009        dvd != NULL; dvd = ctf_list_next (dvd), nvars++);
1010
1011   type_size = ctf_type_sect_size (fp);
1012
1013   /* Compute the size of the CTF buffer we need, sans only the string table,
1014      then allocate a new buffer and memcpy the finished header to the start of
1015      the buffer.  (We will adjust this later with strtab length info.)  */
1016
1017   hdr.cth_lbloff = hdr.cth_objtoff = 0;
1018   hdr.cth_funcoff = hdr.cth_objtoff + objt_size;
1019   hdr.cth_objtidxoff = hdr.cth_funcoff + func_size;
1020   hdr.cth_funcidxoff = hdr.cth_objtidxoff + objtidx_size;
1021   hdr.cth_varoff = hdr.cth_funcidxoff + funcidx_size;
1022   hdr.cth_typeoff = hdr.cth_varoff + (nvars * sizeof (ctf_varent_t));
1023   hdr.cth_stroff = hdr.cth_typeoff + type_size;
1024   hdr.cth_strlen = 0;
1025
1026   buf_size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
1027
1028   if ((buf = malloc (buf_size)) == NULL)
1029     return (ctf_set_errno (fp, EAGAIN));
1030
1031   memcpy (buf, &hdr, sizeof (ctf_header_t));
1032   t = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_objtoff;
1033
1034   hdrp = (ctf_header_t *) buf;
1035   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parname != NULL))
1036     ctf_str_add_ref (fp, fp->ctf_parname, &hdrp->cth_parname);
1037   if (fp->ctf_cuname != NULL)
1038     ctf_str_add_ref (fp, fp->ctf_cuname, &hdrp->cth_cuname);
1039
1040   if (ctf_emit_symtypetab_sects (fp, &symstate, &t, objt_size, func_size,
1041                                  objtidx_size, funcidx_size) < 0)
1042     goto err;
1043
1044   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_varoff);
1045
1046   /* Work over the variable list, translating everything into ctf_varent_t's and
1047      prepping the string table.  */
1048
1049   dvarents = (ctf_varent_t *) t;
1050   for (i = 0, dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
1051        dvd = ctf_list_next (dvd), i++)
1052     {
1053       ctf_varent_t *var = &dvarents[i];
1054
1055       ctf_str_add_ref (fp, dvd->dvd_name, &var->ctv_name);
1056       var->ctv_type = (uint32_t) dvd->dvd_type;
1057     }
1058   assert (i == nvars);
1059
1060   t += sizeof (ctf_varent_t) * nvars;
1061
1062   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_typeoff);
1063
1064   ctf_emit_type_sect (fp, &t);
1065
1066   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff);
1067
1068   /* Every string added outside serialization by ctf_str_add_pending should
1069      now have been added by ctf_add_ref.  */
1070   num_missed_str_refs = ctf_dynset_elements (fp->ctf_str_pending_ref);
1071   if (!ctf_assert (fp, num_missed_str_refs == 0))
1072     goto err;                                   /* errno is set for us.  */
1073
1074   /* Construct the final string table and fill out all the string refs with the
1075      final offsets.  Then purge the refs list, because we're about to move this
1076      strtab onto the end of the buf, invalidating all the offsets.  */
1077   strtab = ctf_str_write_strtab (fp);
1078   ctf_str_purge_refs (fp);
1079
1080   if (strtab.cts_strs == NULL)
1081     goto oom;
1082
1083   /* Now the string table is constructed, we can sort the buffer of
1084      ctf_varent_t's.  */
1085   ctf_sort_var_arg_cb_t sort_var_arg = { fp, (ctf_strs_t *) &strtab };
1086   ctf_qsort_r (dvarents, nvars, sizeof (ctf_varent_t), ctf_sort_var,
1087                &sort_var_arg);
1088
1089   if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
1090     {
1091       free (strtab.cts_strs);
1092       goto oom;
1093     }
1094   buf = newbuf;
1095   memcpy (buf + buf_size, strtab.cts_strs, strtab.cts_len);
1096   hdrp = (ctf_header_t *) buf;
1097   hdrp->cth_strlen = strtab.cts_len;
1098   buf_size += hdrp->cth_strlen;
1099   free (strtab.cts_strs);
1100
1101   /* Finally, we are ready to ctf_simple_open() the new dict.  If this is
1102      successful, we then switch nfp and fp and free the old dict.  */
1103
1104   if ((nfp = ctf_simple_open_internal ((char *) buf, buf_size, NULL, 0,
1105                                        0, NULL, 0, fp->ctf_syn_ext_strtab,
1106                                        1, &err)) == NULL)
1107     {
1108       free (buf);
1109       return (ctf_set_errno (fp, err));
1110     }
1111
1112   (void) ctf_setmodel (nfp, ctf_getmodel (fp));
1113
1114   nfp->ctf_parent = fp->ctf_parent;
1115   nfp->ctf_parent_unreffed = fp->ctf_parent_unreffed;
1116   nfp->ctf_refcnt = fp->ctf_refcnt;
1117   nfp->ctf_flags |= fp->ctf_flags & ~LCTF_DIRTY;
1118   if (nfp->ctf_dynbase == NULL)
1119     nfp->ctf_dynbase = buf;             /* Make sure buf is freed on close.  */
1120   nfp->ctf_dthash = fp->ctf_dthash;
1121   nfp->ctf_dtdefs = fp->ctf_dtdefs;
1122   nfp->ctf_dvhash = fp->ctf_dvhash;
1123   nfp->ctf_dvdefs = fp->ctf_dvdefs;
1124   nfp->ctf_dtoldid = fp->ctf_dtoldid;
1125   nfp->ctf_add_processing = fp->ctf_add_processing;
1126   nfp->ctf_snapshots = fp->ctf_snapshots + 1;
1127   nfp->ctf_specific = fp->ctf_specific;
1128   nfp->ctf_nfuncidx = fp->ctf_nfuncidx;
1129   nfp->ctf_nobjtidx = fp->ctf_nobjtidx;
1130   nfp->ctf_objthash = fp->ctf_objthash;
1131   nfp->ctf_funchash = fp->ctf_funchash;
1132   nfp->ctf_dynsyms = fp->ctf_dynsyms;
1133   nfp->ctf_ptrtab = fp->ctf_ptrtab;
1134   nfp->ctf_pptrtab = fp->ctf_pptrtab;
1135   nfp->ctf_typemax = fp->ctf_typemax;
1136   nfp->ctf_dynsymidx = fp->ctf_dynsymidx;
1137   nfp->ctf_dynsymmax = fp->ctf_dynsymmax;
1138   nfp->ctf_ptrtab_len = fp->ctf_ptrtab_len;
1139   nfp->ctf_pptrtab_len = fp->ctf_pptrtab_len;
1140   nfp->ctf_link_inputs = fp->ctf_link_inputs;
1141   nfp->ctf_link_outputs = fp->ctf_link_outputs;
1142   nfp->ctf_errs_warnings = fp->ctf_errs_warnings;
1143   nfp->ctf_funcidx_names = fp->ctf_funcidx_names;
1144   nfp->ctf_objtidx_names = fp->ctf_objtidx_names;
1145   nfp->ctf_funcidx_sxlate = fp->ctf_funcidx_sxlate;
1146   nfp->ctf_objtidx_sxlate = fp->ctf_objtidx_sxlate;
1147   nfp->ctf_str_prov_offset = fp->ctf_str_prov_offset;
1148   nfp->ctf_syn_ext_strtab = fp->ctf_syn_ext_strtab;
1149   nfp->ctf_pptrtab_typemax = fp->ctf_pptrtab_typemax;
1150   nfp->ctf_in_flight_dynsyms = fp->ctf_in_flight_dynsyms;
1151   nfp->ctf_link_in_cu_mapping = fp->ctf_link_in_cu_mapping;
1152   nfp->ctf_link_out_cu_mapping = fp->ctf_link_out_cu_mapping;
1153   nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
1154   nfp->ctf_link_memb_name_changer = fp->ctf_link_memb_name_changer;
1155   nfp->ctf_link_memb_name_changer_arg = fp->ctf_link_memb_name_changer_arg;
1156   nfp->ctf_link_variable_filter = fp->ctf_link_variable_filter;
1157   nfp->ctf_link_variable_filter_arg = fp->ctf_link_variable_filter_arg;
1158   nfp->ctf_symsect_little_endian = fp->ctf_symsect_little_endian;
1159   nfp->ctf_link_flags = fp->ctf_link_flags;
1160   nfp->ctf_dedup_atoms = fp->ctf_dedup_atoms;
1161   nfp->ctf_dedup_atoms_alloc = fp->ctf_dedup_atoms_alloc;
1162   memcpy (&nfp->ctf_dedup, &fp->ctf_dedup, sizeof (fp->ctf_dedup));
1163
1164   nfp->ctf_snapshot_lu = fp->ctf_snapshots;
1165
1166   memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
1167   nfp->ctf_structs = fp->ctf_structs;
1168   nfp->ctf_unions = fp->ctf_unions;
1169   nfp->ctf_enums = fp->ctf_enums;
1170   nfp->ctf_names = fp->ctf_names;
1171
1172   fp->ctf_dthash = NULL;
1173   ctf_str_free_atoms (nfp);
1174   nfp->ctf_str_atoms = fp->ctf_str_atoms;
1175   nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
1176   nfp->ctf_str_pending_ref = fp->ctf_str_pending_ref;
1177   fp->ctf_str_atoms = NULL;
1178   fp->ctf_prov_strtab = NULL;
1179   fp->ctf_str_pending_ref = NULL;
1180   memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
1181   memset (&fp->ctf_errs_warnings, 0, sizeof (ctf_list_t));
1182   fp->ctf_add_processing = NULL;
1183   fp->ctf_ptrtab = NULL;
1184   fp->ctf_pptrtab = NULL;
1185   fp->ctf_funcidx_names = NULL;
1186   fp->ctf_objtidx_names = NULL;
1187   fp->ctf_funcidx_sxlate = NULL;
1188   fp->ctf_objtidx_sxlate = NULL;
1189   fp->ctf_objthash = NULL;
1190   fp->ctf_funchash = NULL;
1191   fp->ctf_dynsyms = NULL;
1192   fp->ctf_dynsymidx = NULL;
1193   fp->ctf_link_inputs = NULL;
1194   fp->ctf_link_outputs = NULL;
1195   fp->ctf_syn_ext_strtab = NULL;
1196   fp->ctf_link_in_cu_mapping = NULL;
1197   fp->ctf_link_out_cu_mapping = NULL;
1198   fp->ctf_link_type_mapping = NULL;
1199   fp->ctf_dedup_atoms = NULL;
1200   fp->ctf_dedup_atoms_alloc = NULL;
1201   fp->ctf_parent_unreffed = 1;
1202
1203   fp->ctf_dvhash = NULL;
1204   memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
1205   memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
1206   memset (&fp->ctf_in_flight_dynsyms, 0, sizeof (fp->ctf_in_flight_dynsyms));
1207   memset (&fp->ctf_dedup, 0, sizeof (fp->ctf_dedup));
1208   fp->ctf_structs.ctn_writable = NULL;
1209   fp->ctf_unions.ctn_writable = NULL;
1210   fp->ctf_enums.ctn_writable = NULL;
1211   fp->ctf_names.ctn_writable = NULL;
1212
1213   memcpy (&ofp, fp, sizeof (ctf_dict_t));
1214   memcpy (fp, nfp, sizeof (ctf_dict_t));
1215   memcpy (nfp, &ofp, sizeof (ctf_dict_t));
1216
1217   nfp->ctf_refcnt = 1;                          /* Force nfp to be freed.  */
1218   ctf_dict_close (nfp);
1219
1220   return 0;
1221
1222 oom:
1223   free (buf);
1224   return (ctf_set_errno (fp, EAGAIN));
1225 err:
1226   free (buf);
1227   return -1;                                    /* errno is set for us.  */
1228 }
1229
1230 /* File writing.  */
1231
1232 /* Write the compressed CTF data stream to the specified gzFile descriptor.  */
1233 int
1234 ctf_gzwrite (ctf_dict_t *fp, gzFile fd)
1235 {
1236   const unsigned char *buf;
1237   ssize_t resid;
1238   ssize_t len;
1239
1240   resid = sizeof (ctf_header_t);
1241   buf = (unsigned char *) fp->ctf_header;
1242   while (resid != 0)
1243     {
1244       if ((len = gzwrite (fd, buf, resid)) <= 0)
1245         return (ctf_set_errno (fp, errno));
1246       resid -= len;
1247       buf += len;
1248     }
1249
1250   resid = fp->ctf_size;
1251   buf = fp->ctf_buf;
1252   while (resid != 0)
1253     {
1254       if ((len = gzwrite (fd, buf, resid)) <= 0)
1255         return (ctf_set_errno (fp, errno));
1256       resid -= len;
1257       buf += len;
1258     }
1259
1260   return 0;
1261 }
1262
1263 /* Compress the specified CTF data stream and write it to the specified file
1264    descriptor.  */
1265 int
1266 ctf_compress_write (ctf_dict_t *fp, int fd)
1267 {
1268   unsigned char *buf;
1269   unsigned char *bp;
1270   ctf_header_t h;
1271   ctf_header_t *hp = &h;
1272   ssize_t header_len = sizeof (ctf_header_t);
1273   ssize_t compress_len;
1274   ssize_t len;
1275   int rc;
1276   int err = 0;
1277
1278   if (ctf_serialize (fp) < 0)
1279     return -1;                                  /* errno is set for us.  */
1280
1281   memcpy (hp, fp->ctf_header, header_len);
1282   hp->cth_flags |= CTF_F_COMPRESS;
1283   compress_len = compressBound (fp->ctf_size);
1284
1285   if ((buf = malloc (compress_len)) == NULL)
1286     {
1287       ctf_err_warn (fp, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
1288                     (unsigned long) compress_len);
1289       return (ctf_set_errno (fp, ECTF_ZALLOC));
1290     }
1291
1292   if ((rc = compress (buf, (uLongf *) &compress_len,
1293                       fp->ctf_buf, fp->ctf_size)) != Z_OK)
1294     {
1295       err = ctf_set_errno (fp, ECTF_COMPRESS);
1296       ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
1297       goto ret;
1298     }
1299
1300   while (header_len > 0)
1301     {
1302       if ((len = write (fd, hp, header_len)) < 0)
1303         {
1304           err = ctf_set_errno (fp, errno);
1305           ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing header"));
1306           goto ret;
1307         }
1308       header_len -= len;
1309       hp += len;
1310     }
1311
1312   bp = buf;
1313   while (compress_len > 0)
1314     {
1315       if ((len = write (fd, bp, compress_len)) < 0)
1316         {
1317           err = ctf_set_errno (fp, errno);
1318           ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing"));
1319           goto ret;
1320         }
1321       compress_len -= len;
1322       bp += len;
1323     }
1324
1325 ret:
1326   free (buf);
1327   return err;
1328 }
1329
1330 /* Optionally compress the specified CTF data stream and return it as a new
1331    dynamically-allocated string.  */
1332 unsigned char *
1333 ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
1334 {
1335   unsigned char *buf;
1336   unsigned char *bp;
1337   ctf_header_t *hp;
1338   ssize_t header_len = sizeof (ctf_header_t);
1339   ssize_t compress_len;
1340   int rc;
1341
1342   if (ctf_serialize (fp) < 0)
1343     return NULL;                                /* errno is set for us.  */
1344
1345   compress_len = compressBound (fp->ctf_size);
1346   if (fp->ctf_size < threshold)
1347     compress_len = fp->ctf_size;
1348   if ((buf = malloc (compress_len
1349                      + sizeof (struct ctf_header))) == NULL)
1350     {
1351       ctf_set_errno (fp, ENOMEM);
1352       ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
1353                     (unsigned long) (compress_len + sizeof (struct ctf_header)));
1354       return NULL;
1355     }
1356
1357   hp = (ctf_header_t *) buf;
1358   memcpy (hp, fp->ctf_header, header_len);
1359   bp = buf + sizeof (struct ctf_header);
1360   *size = sizeof (struct ctf_header);
1361
1362   if (fp->ctf_size < threshold)
1363     {
1364       hp->cth_flags &= ~CTF_F_COMPRESS;
1365       memcpy (bp, fp->ctf_buf, fp->ctf_size);
1366       *size += fp->ctf_size;
1367     }
1368   else
1369     {
1370       hp->cth_flags |= CTF_F_COMPRESS;
1371       if ((rc = compress (bp, (uLongf *) &compress_len,
1372                           fp->ctf_buf, fp->ctf_size)) != Z_OK)
1373         {
1374           ctf_set_errno (fp, ECTF_COMPRESS);
1375           ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
1376           free (buf);
1377           return NULL;
1378         }
1379       *size += compress_len;
1380     }
1381   return buf;
1382 }
1383
1384 /* Write the uncompressed CTF data stream to the specified file descriptor.  */
1385 int
1386 ctf_write (ctf_dict_t *fp, int fd)
1387 {
1388   const unsigned char *buf;
1389   ssize_t resid;
1390   ssize_t len;
1391
1392   if (ctf_serialize (fp) < 0)
1393     return -1;                                  /* errno is set for us.  */
1394
1395   resid = sizeof (ctf_header_t);
1396   buf = (unsigned char *) fp->ctf_header;
1397   while (resid != 0)
1398     {
1399       if ((len = write (fd, buf, resid)) <= 0)
1400         {
1401           ctf_err_warn (fp, 0, errno, _("ctf_write: error writing header"));
1402           return (ctf_set_errno (fp, errno));
1403         }
1404       resid -= len;
1405       buf += len;
1406     }
1407
1408   resid = fp->ctf_size;
1409   buf = fp->ctf_buf;
1410   while (resid != 0)
1411     {
1412       if ((len = write (fd, buf, resid)) <= 0)
1413         {
1414           ctf_err_warn (fp, 0, errno, _("ctf_write: error writing"));
1415           return (ctf_set_errno (fp, errno));
1416         }
1417       resid -= len;
1418       buf += len;
1419     }
1420
1421   return 0;
1422 }