libctf/ctf-serialize.c

   1 /* CTF dict creation.
   2    Copyright (C) 2019-2021 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 data symbols that have been assigned names from the variable section.
 435    Must be called from within ctf_serialize, because that is the only place
 436    you can safely delete variables without messing up ctf_rollback.  */
 437
 438 static int
 439 symtypetab_delete_nonstatic_vars (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           && ctf_dynhash_lookup (symfp->ctf_dynsyms, dvd->dvd_name) != NULL
 451           && type == dvd->dvd_type)
 452         ctf_dvd_delete (fp, dvd);
 453     }
 454
 455   return 0;
 456 }
 457
 458 /* Figure out the sizes of the symtypetab sections, their indexed state,
 459    etc.  */
 460 static int
 461 ctf_symtypetab_sect_sizes (ctf_dict_t *fp, emit_symtypetab_state_t *s,
 462                            ctf_header_t *hdr, size_t *objt_size,
 463                            size_t *func_size, size_t *objtidx_size,
 464                            size_t *funcidx_size)
 465 {
 466   size_t nfuncs, nobjts;
 467   size_t objt_unpadsize, func_unpadsize, objt_padsize, func_padsize;
 468
 469   /* If doing a writeout as part of linking, and the link flags request it,
 470      filter out reported symbols from the variable section, and filter out all
 471      other symbols from the symtypetab sections.  (If we are not linking, the
 472      symbols are sorted; if we are linking, don't bother sorting if we are not
 473      filtering out reported symbols: this is almost certaily an ld -r and only
 474      the linker is likely to consume these symtypetabs again.  The linker
 475      doesn't care what order the symtypetab entries is in, since it only
 476      iterates over symbols and does not use the ctf_lookup_by_symbol* API.)  */
 477
 478   s->sort_syms = 1;
 479   if (fp->ctf_flags & LCTF_LINKING)
 480     {
 481       s->filter_syms = !(fp->ctf_link_flags & CTF_LINK_NO_FILTER_REPORTED_SYMS);
 482       if (!s->filter_syms)
 483         s->sort_syms = 0;
 484     }
 485
 486   /* Find the dict to which the linker has reported symbols, if any.  */
 487
 488   if (s->filter_syms)
 489     {
 490       if (!fp->ctf_dynsyms && fp->ctf_parent && fp->ctf_parent->ctf_dynsyms)
 491         s->symfp = fp->ctf_parent;
 492       else
 493         s->symfp = fp;
 494     }
 495
 496   /* If not filtering, keep all potential symbols in an unsorted, indexed
 497      dict.  */
 498   if (!s->filter_syms)
 499     s->symflags = CTF_SYMTYPETAB_FORCE_INDEXED;
 500   else
 501     hdr->cth_flags |= CTF_F_IDXSORTED;
 502
 503   if (!ctf_assert (fp, (s->filter_syms && s->symfp)
 504                    || (!s->filter_syms && !s->symfp
 505                        && ((s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED) != 0))))
 506     return -1;
 507
 508   /* Work out the sizes of the object and function sections, and work out the
 509      number of pad (unassigned) symbols in each, and the overall size of the
 510      sections.  */
 511
 512   if (symtypetab_density (fp, s->symfp, fp->ctf_objthash, &nobjts, &s->maxobjt,
 513                           &objt_unpadsize, &objt_padsize, objtidx_size,
 514                           s->symflags) < 0)
 515     return -1;                                  /* errno is set for us.  */
 516
 517   ctf_dprintf ("Object symtypetab: %i objects, max %i, unpadded size %i, "
 518                "%i bytes of pads, index size %i\n", (int) nobjts,
 519                (int) s->maxobjt, (int) objt_unpadsize, (int) objt_padsize,
 520                (int) *objtidx_size);
 521
 522   if (symtypetab_density (fp, s->symfp, fp->ctf_funchash, &nfuncs, &s->maxfunc,
 523                           &func_unpadsize, &func_padsize, funcidx_size,
 524                           s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 525     return -1;                                  /* errno is set for us.  */
 526
 527   ctf_dprintf ("Function symtypetab: %i functions, max %i, unpadded size %i, "
 528                "%i bytes of pads, index size %i\n", (int) nfuncs,
 529                (int) s->maxfunc, (int) func_unpadsize, (int) func_padsize,
 530                (int) *funcidx_size);
 531
 532   /* It is worth indexing each section if it would save space to do so, due to
 533      reducing the number of pads sufficiently.  A pad is the same size as a
 534      single index entry: but index sections compress relatively poorly compared
 535      to constant pads, so it takes a lot of contiguous padding to equal one
 536      index section entry.  It would be nice to be able to *verify* whether we
 537      would save space after compression rather than guessing, but this seems
 538      difficult, since it would require complete reserialization.  Regardless, if
 539      the linker has not reported any symbols (e.g. if this is not a final link
 540      but just an ld -r), we must emit things in indexed fashion just as the
 541      compiler does.  */
 542
 543   *objt_size = objt_unpadsize;
 544   if (!(s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
 545       && ((objt_padsize + objt_unpadsize) * CTF_INDEX_PAD_THRESHOLD
 546           > objt_padsize))
 547     {
 548       *objt_size += objt_padsize;
 549       *objtidx_size = 0;
 550     }
 551
 552   *func_size = func_unpadsize;
 553   if (!(s->symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
 554       && ((func_padsize + func_unpadsize) * CTF_INDEX_PAD_THRESHOLD
 555           > func_padsize))
 556     {
 557       *func_size += func_padsize;
 558       *funcidx_size = 0;
 559     }
 560
 561   /* If we are filtering symbols out, those symbols that the linker has not
 562      reported have now been removed from the ctf_objthash and ctf_funchash.
 563      Delete entries from the variable section that duplicate newly-added data
 564      symbols.  There's no need to migrate new ones in, because the compiler
 565      always emits both a variable and a data symbol simultaneously, and
 566      filtering only happens at final link time.  */
 567
 568   if (s->filter_syms && s->symfp->ctf_dynsyms &&
 569       symtypetab_delete_nonstatic_vars (fp, s->symfp) < 0)
 570     return -1;
 571
 572   return 0;
 573 }
 574
 575 static int
 576 ctf_emit_symtypetab_sects (ctf_dict_t *fp, emit_symtypetab_state_t *s,
 577                            unsigned char **tptr, size_t objt_size,
 578                            size_t func_size, size_t objtidx_size,
 579                            size_t funcidx_size)
 580 {
 581   unsigned char *t = *tptr;
 582   size_t nsymtypes = 0;
 583   const char **sym_name_order = NULL;
 584   int err;
 585
 586   /* Sort the linker's symbols into name order if need be.  */
 587
 588   if ((objtidx_size != 0) || (funcidx_size != 0))
 589     {
 590       ctf_next_t *i = NULL;
 591       void *symname;
 592       const char **walk;
 593
 594       if (s->filter_syms)
 595         {
 596           if (s->symfp->ctf_dynsyms)
 597             nsymtypes = ctf_dynhash_elements (s->symfp->ctf_dynsyms);
 598           else
 599             nsymtypes = 0;
 600         }
 601       else
 602         nsymtypes = ctf_dynhash_elements (fp->ctf_objthash)
 603           + ctf_dynhash_elements (fp->ctf_funchash);
 604
 605       if ((sym_name_order = calloc (nsymtypes, sizeof (const char *))) == NULL)
 606         goto oom;
 607
 608       walk = sym_name_order;
 609
 610       if (s->filter_syms)
 611         {
 612           if (s->symfp->ctf_dynsyms)
 613             {
 614               while ((err = ctf_dynhash_next_sorted (s->symfp->ctf_dynsyms, &i,
 615                                                      &symname, NULL,
 616                                                      ctf_dynhash_sort_by_name,
 617                                                      NULL)) == 0)
 618                 *walk++ = (const char *) symname;
 619               if (err != ECTF_NEXT_END)
 620                 goto symerr;
 621             }
 622         }
 623       else
 624         {
 625           ctf_hash_sort_f sort_fun = NULL;
 626
 627           /* Since we partition the set of symbols back into objt and func,
 628              we can sort the two independently without harm.  */
 629           if (s->sort_syms)
 630             sort_fun = ctf_dynhash_sort_by_name;
 631
 632           while ((err = ctf_dynhash_next_sorted (fp->ctf_objthash, &i, &symname,
 633                                                  NULL, sort_fun, NULL)) == 0)
 634             *walk++ = (const char *) symname;
 635           if (err != ECTF_NEXT_END)
 636             goto symerr;
 637
 638           while ((err = ctf_dynhash_next_sorted (fp->ctf_funchash, &i, &symname,
 639                                                  NULL, sort_fun, NULL)) == 0)
 640             *walk++ = (const char *) symname;
 641           if (err != ECTF_NEXT_END)
 642             goto symerr;
 643         }
 644     }
 645
 646   /* Emit the object and function sections, and if necessary their indexes.
 647      Emission is done in symtab order if there is no index, and in index
 648      (name) order otherwise.  */
 649
 650   if ((objtidx_size == 0) && s->symfp && s->symfp->ctf_dynsymidx)
 651     {
 652       ctf_dprintf ("Emitting unindexed objt symtypetab\n");
 653       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t,
 654                            s->symfp->ctf_dynsymidx, NULL,
 655                            s->symfp->ctf_dynsymmax + 1, s->maxobjt,
 656                            objt_size, s->symflags | CTF_SYMTYPETAB_EMIT_PAD) < 0)
 657         goto err;                               /* errno is set for us.  */
 658     }
 659   else
 660     {
 661       ctf_dprintf ("Emitting indexed objt symtypetab\n");
 662       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t, NULL,
 663                            sym_name_order, nsymtypes, s->maxobjt,
 664                            objt_size, s->symflags) < 0)
 665         goto err;                               /* errno is set for us.  */
 666     }
 667
 668   t += objt_size;
 669
 670   if ((funcidx_size == 0) && s->symfp && s->symfp->ctf_dynsymidx)
 671     {
 672       ctf_dprintf ("Emitting unindexed func symtypetab\n");
 673       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t,
 674                            s->symfp->ctf_dynsymidx, NULL,
 675                            s->symfp->ctf_dynsymmax + 1, s->maxfunc,
 676                            func_size, s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION
 677                            | CTF_SYMTYPETAB_EMIT_PAD) < 0)
 678         goto err;                               /* errno is set for us.  */
 679     }
 680   else
 681     {
 682       ctf_dprintf ("Emitting indexed func symtypetab\n");
 683       if (emit_symtypetab (fp, s->symfp, (uint32_t *) t, NULL, sym_name_order,
 684                            nsymtypes, s->maxfunc, func_size,
 685                            s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 686         goto err;                               /* errno is set for us.  */
 687     }
 688
 689   t += func_size;
 690
 691   if (objtidx_size > 0)
 692     if (emit_symtypetab_index (fp, s->symfp, (uint32_t *) t, sym_name_order,
 693                                nsymtypes, objtidx_size, s->symflags) < 0)
 694       goto err;
 695
 696   t += objtidx_size;
 697
 698   if (funcidx_size > 0)
 699     if (emit_symtypetab_index (fp, s->symfp, (uint32_t *) t, sym_name_order,
 700                                nsymtypes, funcidx_size,
 701                                s->symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
 702       goto err;
 703
 704   t += funcidx_size;
 705   free (sym_name_order);
 706   *tptr = t;
 707
 708   return 0;
 709
 710  oom:
 711   ctf_set_errno (fp, EAGAIN);
 712   goto err;
 713 symerr:
 714   ctf_err_warn (fp, 0, err, _("error serializing symtypetabs"));
 715  err:
 716   free (sym_name_order);
 717   return -1;
 718 }
 719
 720 /* Type section.  */
 721
 722 static unsigned char *
 723 ctf_copy_smembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 724 {
 725   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 726   ctf_member_t ctm;
 727
 728   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 729     {
 730       ctf_member_t *copied;
 731
 732       ctm.ctm_name = 0;
 733       ctm.ctm_type = (uint32_t) dmd->dmd_type;
 734       ctm.ctm_offset = (uint32_t) dmd->dmd_offset;
 735
 736       memcpy (t, &ctm, sizeof (ctm));
 737       copied = (ctf_member_t *) t;
 738       if (dmd->dmd_name)
 739         ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctm_name);
 740
 741       t += sizeof (ctm);
 742     }
 743
 744   return t;
 745 }
 746
 747 static unsigned char *
 748 ctf_copy_lmembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 749 {
 750   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 751   ctf_lmember_t ctlm;
 752
 753   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 754     {
 755       ctf_lmember_t *copied;
 756
 757       ctlm.ctlm_name = 0;
 758       ctlm.ctlm_type = (uint32_t) dmd->dmd_type;
 759       ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset);
 760       ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset);
 761
 762       memcpy (t, &ctlm, sizeof (ctlm));
 763       copied = (ctf_lmember_t *) t;
 764       if (dmd->dmd_name)
 765         ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctlm_name);
 766
 767       t += sizeof (ctlm);
 768     }
 769
 770   return t;
 771 }
 772
 773 static unsigned char *
 774 ctf_copy_emembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 775 {
 776   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 777   ctf_enum_t cte;
 778
 779   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 780     {
 781       ctf_enum_t *copied;
 782
 783       cte.cte_value = dmd->dmd_value;
 784       memcpy (t, &cte, sizeof (cte));
 785       copied = (ctf_enum_t *) t;
 786       ctf_str_add_ref (fp, dmd->dmd_name, &copied->cte_name);
 787       t += sizeof (cte);
 788     }
 789
 790   return t;
 791 }
 792
 793 /* Iterate through the dynamic type definition list and compute the
 794    size of the CTF type section.  */
 795
 796 static size_t
 797 ctf_type_sect_size (ctf_dict_t *fp)
 798 {
 799   ctf_dtdef_t *dtd;
 800   size_t type_size;
 801
 802   for (type_size = 0, dtd = ctf_list_next (&fp->ctf_dtdefs);
 803        dtd != NULL; dtd = ctf_list_next (dtd))
 804     {
 805       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 806       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 807
 808       if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
 809         type_size += sizeof (ctf_stype_t);
 810       else
 811         type_size += sizeof (ctf_type_t);
 812
 813       switch (kind)
 814         {
 815         case CTF_K_INTEGER:
 816         case CTF_K_FLOAT:
 817           type_size += sizeof (uint32_t);
 818           break;
 819         case CTF_K_ARRAY:
 820           type_size += sizeof (ctf_array_t);
 821           break;
 822         case CTF_K_SLICE:
 823           type_size += sizeof (ctf_slice_t);
 824           break;
 825         case CTF_K_FUNCTION:
 826           type_size += sizeof (uint32_t) * (vlen + (vlen & 1));
 827           break;
 828         case CTF_K_STRUCT:
 829         case CTF_K_UNION:
 830           if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
 831             type_size += sizeof (ctf_member_t) * vlen;
 832           else
 833             type_size += sizeof (ctf_lmember_t) * vlen;
 834           break;
 835         case CTF_K_ENUM:
 836           type_size += sizeof (ctf_enum_t) * vlen;
 837           break;
 838         }
 839     }
 840
 841   return type_size;
 842 }
 843
 844 /* Take a final lap through the dynamic type definition list and copy the
 845    appropriate type records to the output buffer, noting down the strings as
 846    we go.  */
 847
 848 static void
 849 ctf_emit_type_sect (ctf_dict_t *fp, unsigned char **tptr)
 850 {
 851   unsigned char *t = *tptr;
 852   ctf_dtdef_t *dtd;
 853
 854   for (dtd = ctf_list_next (&fp->ctf_dtdefs);
 855        dtd != NULL; dtd = ctf_list_next (dtd))
 856     {
 857       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 858       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 859
 860       ctf_array_t cta;
 861       uint32_t encoding;
 862       size_t len;
 863       ctf_stype_t *copied;
 864       const char *name;
 865
 866       if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
 867         len = sizeof (ctf_stype_t);
 868       else
 869         len = sizeof (ctf_type_t);
 870
 871       memcpy (t, &dtd->dtd_data, len);
 872       copied = (ctf_stype_t *) t;  /* name is at the start: constant offset.  */
 873       if (copied->ctt_name
 874           && (name = ctf_strraw (fp, copied->ctt_name)) != NULL)
 875         ctf_str_add_ref (fp, name, &copied->ctt_name);
 876       t += len;
 877
 878       switch (kind)
 879         {
 880         case CTF_K_INTEGER:
 881         case CTF_K_FLOAT:
 882           if (kind == CTF_K_INTEGER)
 883             {
 884               encoding = CTF_INT_DATA (dtd->dtd_u.dtu_enc.cte_format,
 885                                        dtd->dtd_u.dtu_enc.cte_offset,
 886                                        dtd->dtd_u.dtu_enc.cte_bits);
 887             }
 888           else
 889             {
 890               encoding = CTF_FP_DATA (dtd->dtd_u.dtu_enc.cte_format,
 891                                       dtd->dtd_u.dtu_enc.cte_offset,
 892                                       dtd->dtd_u.dtu_enc.cte_bits);
 893             }
 894           memcpy (t, &encoding, sizeof (encoding));
 895           t += sizeof (encoding);
 896           break;
 897
 898         case CTF_K_SLICE:
 899           memcpy (t, &dtd->dtd_u.dtu_slice, sizeof (struct ctf_slice));
 900           t += sizeof (struct ctf_slice);
 901           break;
 902
 903         case CTF_K_ARRAY:
 904           cta.cta_contents = (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents;
 905           cta.cta_index = (uint32_t) dtd->dtd_u.dtu_arr.ctr_index;
 906           cta.cta_nelems = dtd->dtd_u.dtu_arr.ctr_nelems;
 907           memcpy (t, &cta, sizeof (cta));
 908           t += sizeof (cta);
 909           break;
 910
 911         case CTF_K_FUNCTION:
 912           {
 913             uint32_t *argv = (uint32_t *) (uintptr_t) t;
 914             uint32_t argc;
 915
 916             for (argc = 0; argc < vlen; argc++)
 917               *argv++ = dtd->dtd_u.dtu_argv[argc];
 918
 919             if (vlen & 1)
 920               *argv++ = 0;      /* Pad to 4-byte boundary.  */
 921
 922             t = (unsigned char *) argv;
 923             break;
 924           }
 925
 926         case CTF_K_STRUCT:
 927         case CTF_K_UNION:
 928           if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
 929             t = ctf_copy_smembers (fp, dtd, t);
 930           else
 931             t = ctf_copy_lmembers (fp, dtd, t);
 932           break;
 933
 934         case CTF_K_ENUM:
 935           t = ctf_copy_emembers (fp, dtd, t);
 936           break;
 937         }
 938     }
 939
 940   *tptr = t;
 941 }
 942
 943 /* Variable section.  */
 944
 945 /* Sort a newly-constructed static variable array.  */
 946
 947 typedef struct ctf_sort_var_arg_cb
 948 {
 949   ctf_dict_t *fp;
 950   ctf_strs_t *strtab;
 951 } ctf_sort_var_arg_cb_t;
 952
 953 static int
 954 ctf_sort_var (const void *one_, const void *two_, void *arg_)
 955 {
 956   const ctf_varent_t *one = one_;
 957   const ctf_varent_t *two = two_;
 958   ctf_sort_var_arg_cb_t *arg = arg_;
 959
 960   return (strcmp (ctf_strraw_explicit (arg->fp, one->ctv_name, arg->strtab),
 961                   ctf_strraw_explicit (arg->fp, two->ctv_name, arg->strtab)));
 962 }
 963
 964 /* Overall serialization.  */
 965
 966 /* If the specified CTF dict is writable and has been modified, reload this dict
 967    with the updated type definitions, ready for serialization.  In order to make
 968    this code and the rest of libctf as simple as possible, we perform updates by
 969    taking the dynamic type definitions and creating an in-memory CTF dict
 970    containing the definitions, and then call ctf_simple_open_internal() on it.
 971    We perform one extra trick here for the benefit of callers and to keep our
 972    code simple: ctf_simple_open_internal() will return a new ctf_dict_t, but we
 973    want to keep the fp constant for the caller, so after
 974    ctf_simple_open_internal() returns, we use memcpy to swap the interior of the
 975    old and new ctf_dict_t's, and then free the old.  */
 976 int
 977 ctf_serialize (ctf_dict_t *fp)
 978 {
 979   ctf_dict_t ofp, *nfp;
 980   ctf_header_t hdr, *hdrp;
 981   ctf_dvdef_t *dvd;
 982   ctf_varent_t *dvarents;
 983   ctf_strs_writable_t strtab;
 984   int err;
 985
 986   unsigned char *t;
 987   unsigned long i;
 988   size_t buf_size, type_size, objt_size, func_size;
 989   size_t funcidx_size, objtidx_size;
 990   size_t nvars;
 991   unsigned char *buf = NULL, *newbuf;
 992
 993   emit_symtypetab_state_t symstate;
 994   memset (&symstate, 0, sizeof (emit_symtypetab_state_t));
 995
 996   if (!(fp->ctf_flags & LCTF_RDWR))
 997     return (ctf_set_errno (fp, ECTF_RDONLY));
 998
 999   /* Update required?  */
1000   if (!(fp->ctf_flags & LCTF_DIRTY))
1001     return 0;
1002
1003   /* Fill in an initial CTF header.  We will leave the label, object,
1004      and function sections empty and only output a header, type section,
1005      and string table.  The type section begins at a 4-byte aligned
1006      boundary past the CTF header itself (at relative offset zero).  The flag
1007      indicating a new-style function info section (an array of CTF_K_FUNCTION
1008      type IDs in the types section) is flipped on.  */
1009
1010   memset (&hdr, 0, sizeof (hdr));
1011   hdr.cth_magic = CTF_MAGIC;
1012   hdr.cth_version = CTF_VERSION;
1013
1014   /* This is a new-format func info section, and the symtab and strtab come out
1015      of the dynsym and dynstr these days.  */
1016   hdr.cth_flags = (CTF_F_NEWFUNCINFO | CTF_F_DYNSTR);
1017
1018   if (ctf_symtypetab_sect_sizes (fp, &symstate, &hdr, &objt_size, &func_size,
1019                                  &objtidx_size, &funcidx_size) < 0)
1020     return -1;                                  /* errno is set for us.  */
1021
1022   for (nvars = 0, dvd = ctf_list_next (&fp->ctf_dvdefs);
1023        dvd != NULL; dvd = ctf_list_next (dvd), nvars++);
1024
1025   type_size = ctf_type_sect_size (fp);
1026
1027   /* Compute the size of the CTF buffer we need, sans only the string table,
1028      then allocate a new buffer and memcpy the finished header to the start of
1029      the buffer.  (We will adjust this later with strtab length info.)  */
1030
1031   hdr.cth_lbloff = hdr.cth_objtoff = 0;
1032   hdr.cth_funcoff = hdr.cth_objtoff + objt_size;
1033   hdr.cth_objtidxoff = hdr.cth_funcoff + func_size;
1034   hdr.cth_funcidxoff = hdr.cth_objtidxoff + objtidx_size;
1035   hdr.cth_varoff = hdr.cth_funcidxoff + funcidx_size;
1036   hdr.cth_typeoff = hdr.cth_varoff + (nvars * sizeof (ctf_varent_t));
1037   hdr.cth_stroff = hdr.cth_typeoff + type_size;
1038   hdr.cth_strlen = 0;
1039
1040   buf_size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
1041
1042   if ((buf = malloc (buf_size)) == NULL)
1043     return (ctf_set_errno (fp, EAGAIN));
1044
1045   memcpy (buf, &hdr, sizeof (ctf_header_t));
1046   t = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_objtoff;
1047
1048   hdrp = (ctf_header_t *) buf;
1049   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parname != NULL))
1050     ctf_str_add_ref (fp, fp->ctf_parname, &hdrp->cth_parname);
1051   if (fp->ctf_cuname != NULL)
1052     ctf_str_add_ref (fp, fp->ctf_cuname, &hdrp->cth_cuname);
1053
1054   if (ctf_emit_symtypetab_sects (fp, &symstate, &t, objt_size, func_size,
1055                                  objtidx_size, funcidx_size) < 0)
1056     goto err;
1057
1058   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_varoff);
1059
1060   /* Work over the variable list, translating everything into ctf_varent_t's and
1061      prepping the string table.  */
1062
1063   dvarents = (ctf_varent_t *) t;
1064   for (i = 0, dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
1065        dvd = ctf_list_next (dvd), i++)
1066     {
1067       ctf_varent_t *var = &dvarents[i];
1068
1069       ctf_str_add_ref (fp, dvd->dvd_name, &var->ctv_name);
1070       var->ctv_type = (uint32_t) dvd->dvd_type;
1071     }
1072   assert (i == nvars);
1073
1074   t += sizeof (ctf_varent_t) * nvars;
1075
1076   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_typeoff);
1077
1078   ctf_emit_type_sect (fp, &t);
1079
1080   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff);
1081
1082   /* Construct the final string table and fill out all the string refs with the
1083      final offsets.  Then purge the refs list, because we're about to move this
1084      strtab onto the end of the buf, invalidating all the offsets.  */
1085   strtab = ctf_str_write_strtab (fp);
1086   ctf_str_purge_refs (fp);
1087
1088   if (strtab.cts_strs == NULL)
1089     goto oom;
1090
1091   /* Now the string table is constructed, we can sort the buffer of
1092      ctf_varent_t's.  */
1093   ctf_sort_var_arg_cb_t sort_var_arg = { fp, (ctf_strs_t *) &strtab };
1094   ctf_qsort_r (dvarents, nvars, sizeof (ctf_varent_t), ctf_sort_var,
1095                &sort_var_arg);
1096
1097   if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
1098     {
1099       free (strtab.cts_strs);
1100       goto oom;
1101     }
1102   buf = newbuf;
1103   memcpy (buf + buf_size, strtab.cts_strs, strtab.cts_len);
1104   hdrp = (ctf_header_t *) buf;
1105   hdrp->cth_strlen = strtab.cts_len;
1106   buf_size += hdrp->cth_strlen;
1107   free (strtab.cts_strs);
1108
1109   /* Finally, we are ready to ctf_simple_open() the new dict.  If this is
1110      successful, we then switch nfp and fp and free the old dict.  */
1111
1112   if ((nfp = ctf_simple_open_internal ((char *) buf, buf_size, NULL, 0,
1113                                        0, NULL, 0, fp->ctf_syn_ext_strtab,
1114                                        1, &err)) == NULL)
1115     {
1116       free (buf);
1117       return (ctf_set_errno (fp, err));
1118     }
1119
1120   (void) ctf_setmodel (nfp, ctf_getmodel (fp));
1121
1122   nfp->ctf_parent = fp->ctf_parent;
1123   nfp->ctf_parent_unreffed = fp->ctf_parent_unreffed;
1124   nfp->ctf_refcnt = fp->ctf_refcnt;
1125   nfp->ctf_flags |= fp->ctf_flags & ~LCTF_DIRTY;
1126   if (nfp->ctf_dynbase == NULL)
1127     nfp->ctf_dynbase = buf;             /* Make sure buf is freed on close.  */
1128   nfp->ctf_dthash = fp->ctf_dthash;
1129   nfp->ctf_dtdefs = fp->ctf_dtdefs;
1130   nfp->ctf_dvhash = fp->ctf_dvhash;
1131   nfp->ctf_dvdefs = fp->ctf_dvdefs;
1132   nfp->ctf_dtoldid = fp->ctf_dtoldid;
1133   nfp->ctf_add_processing = fp->ctf_add_processing;
1134   nfp->ctf_snapshots = fp->ctf_snapshots + 1;
1135   nfp->ctf_specific = fp->ctf_specific;
1136   nfp->ctf_nfuncidx = fp->ctf_nfuncidx;
1137   nfp->ctf_nobjtidx = fp->ctf_nobjtidx;
1138   nfp->ctf_objthash = fp->ctf_objthash;
1139   nfp->ctf_funchash = fp->ctf_funchash;
1140   nfp->ctf_dynsyms = fp->ctf_dynsyms;
1141   nfp->ctf_ptrtab = fp->ctf_ptrtab;
1142   nfp->ctf_pptrtab = fp->ctf_pptrtab;
1143   nfp->ctf_dynsymidx = fp->ctf_dynsymidx;
1144   nfp->ctf_dynsymmax = fp->ctf_dynsymmax;
1145   nfp->ctf_ptrtab_len = fp->ctf_ptrtab_len;
1146   nfp->ctf_pptrtab_len = fp->ctf_pptrtab_len;
1147   nfp->ctf_link_inputs = fp->ctf_link_inputs;
1148   nfp->ctf_link_outputs = fp->ctf_link_outputs;
1149   nfp->ctf_errs_warnings = fp->ctf_errs_warnings;
1150   nfp->ctf_funcidx_names = fp->ctf_funcidx_names;
1151   nfp->ctf_objtidx_names = fp->ctf_objtidx_names;
1152   nfp->ctf_funcidx_sxlate = fp->ctf_funcidx_sxlate;
1153   nfp->ctf_objtidx_sxlate = fp->ctf_objtidx_sxlate;
1154   nfp->ctf_str_prov_offset = fp->ctf_str_prov_offset;
1155   nfp->ctf_syn_ext_strtab = fp->ctf_syn_ext_strtab;
1156   nfp->ctf_pptrtab_typemax = fp->ctf_pptrtab_typemax;
1157   nfp->ctf_in_flight_dynsyms = fp->ctf_in_flight_dynsyms;
1158   nfp->ctf_link_in_cu_mapping = fp->ctf_link_in_cu_mapping;
1159   nfp->ctf_link_out_cu_mapping = fp->ctf_link_out_cu_mapping;
1160   nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
1161   nfp->ctf_link_memb_name_changer = fp->ctf_link_memb_name_changer;
1162   nfp->ctf_link_memb_name_changer_arg = fp->ctf_link_memb_name_changer_arg;
1163   nfp->ctf_link_variable_filter = fp->ctf_link_variable_filter;
1164   nfp->ctf_link_variable_filter_arg = fp->ctf_link_variable_filter_arg;
1165   nfp->ctf_symsect_little_endian = fp->ctf_symsect_little_endian;
1166   nfp->ctf_link_flags = fp->ctf_link_flags;
1167   nfp->ctf_dedup_atoms = fp->ctf_dedup_atoms;
1168   nfp->ctf_dedup_atoms_alloc = fp->ctf_dedup_atoms_alloc;
1169   memcpy (&nfp->ctf_dedup, &fp->ctf_dedup, sizeof (fp->ctf_dedup));
1170
1171   nfp->ctf_snapshot_lu = fp->ctf_snapshots;
1172
1173   memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
1174   nfp->ctf_structs = fp->ctf_structs;
1175   nfp->ctf_unions = fp->ctf_unions;
1176   nfp->ctf_enums = fp->ctf_enums;
1177   nfp->ctf_names = fp->ctf_names;
1178
1179   fp->ctf_dthash = NULL;
1180   ctf_str_free_atoms (nfp);
1181   nfp->ctf_str_atoms = fp->ctf_str_atoms;
1182   nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
1183   fp->ctf_str_atoms = NULL;
1184   fp->ctf_prov_strtab = NULL;
1185   memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
1186   memset (&fp->ctf_errs_warnings, 0, sizeof (ctf_list_t));
1187   fp->ctf_add_processing = NULL;
1188   fp->ctf_ptrtab = NULL;
1189   fp->ctf_pptrtab = NULL;
1190   fp->ctf_funcidx_names = NULL;
1191   fp->ctf_objtidx_names = NULL;
1192   fp->ctf_funcidx_sxlate = NULL;
1193   fp->ctf_objtidx_sxlate = NULL;
1194   fp->ctf_objthash = NULL;
1195   fp->ctf_funchash = NULL;
1196   fp->ctf_dynsyms = NULL;
1197   fp->ctf_dynsymidx = NULL;
1198   fp->ctf_link_inputs = NULL;
1199   fp->ctf_link_outputs = NULL;
1200   fp->ctf_syn_ext_strtab = NULL;
1201   fp->ctf_link_in_cu_mapping = NULL;
1202   fp->ctf_link_out_cu_mapping = NULL;
1203   fp->ctf_link_type_mapping = NULL;
1204   fp->ctf_dedup_atoms = NULL;
1205   fp->ctf_dedup_atoms_alloc = NULL;
1206   fp->ctf_parent_unreffed = 1;
1207
1208   fp->ctf_dvhash = NULL;
1209   memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
1210   memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
1211   memset (&fp->ctf_in_flight_dynsyms, 0, sizeof (fp->ctf_in_flight_dynsyms));
1212   memset (&fp->ctf_dedup, 0, sizeof (fp->ctf_dedup));
1213   fp->ctf_structs.ctn_writable = NULL;
1214   fp->ctf_unions.ctn_writable = NULL;
1215   fp->ctf_enums.ctn_writable = NULL;
1216   fp->ctf_names.ctn_writable = NULL;
1217
1218   memcpy (&ofp, fp, sizeof (ctf_dict_t));
1219   memcpy (fp, nfp, sizeof (ctf_dict_t));
1220   memcpy (nfp, &ofp, sizeof (ctf_dict_t));
1221
1222   nfp->ctf_refcnt = 1;                          /* Force nfp to be freed.  */
1223   ctf_dict_close (nfp);
1224
1225   return 0;
1226
1227 oom:
1228   free (buf);
1229   return (ctf_set_errno (fp, EAGAIN));
1230 err:
1231   free (buf);
1232   return -1;                                    /* errno is set for us.  */
1233 }
1234
1235 /* File writing.  */
1236
1237 /* Write the compressed CTF data stream to the specified gzFile descriptor.  */
1238 int
1239 ctf_gzwrite (ctf_dict_t *fp, gzFile fd)
1240 {
1241   const unsigned char *buf;
1242   ssize_t resid;
1243   ssize_t len;
1244
1245   resid = sizeof (ctf_header_t);
1246   buf = (unsigned char *) fp->ctf_header;
1247   while (resid != 0)
1248     {
1249       if ((len = gzwrite (fd, buf, resid)) <= 0)
1250         return (ctf_set_errno (fp, errno));
1251       resid -= len;
1252       buf += len;
1253     }
1254
1255   resid = fp->ctf_size;
1256   buf = fp->ctf_buf;
1257   while (resid != 0)
1258     {
1259       if ((len = gzwrite (fd, buf, resid)) <= 0)
1260         return (ctf_set_errno (fp, errno));
1261       resid -= len;
1262       buf += len;
1263     }
1264
1265   return 0;
1266 }
1267
1268 /* Compress the specified CTF data stream and write it to the specified file
1269    descriptor.  */
1270 int
1271 ctf_compress_write (ctf_dict_t *fp, int fd)
1272 {
1273   unsigned char *buf;
1274   unsigned char *bp;
1275   ctf_header_t h;
1276   ctf_header_t *hp = &h;
1277   ssize_t header_len = sizeof (ctf_header_t);
1278   ssize_t compress_len;
1279   ssize_t len;
1280   int rc;
1281   int err = 0;
1282
1283   if (ctf_serialize (fp) < 0)
1284     return -1;                                  /* errno is set for us.  */
1285
1286   memcpy (hp, fp->ctf_header, header_len);
1287   hp->cth_flags |= CTF_F_COMPRESS;
1288   compress_len = compressBound (fp->ctf_size);
1289
1290   if ((buf = malloc (compress_len)) == NULL)
1291     {
1292       ctf_err_warn (fp, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
1293                     (unsigned long) compress_len);
1294       return (ctf_set_errno (fp, ECTF_ZALLOC));
1295     }
1296
1297   if ((rc = compress (buf, (uLongf *) &compress_len,
1298                       fp->ctf_buf, fp->ctf_size)) != Z_OK)
1299     {
1300       err = ctf_set_errno (fp, ECTF_COMPRESS);
1301       ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
1302       goto ret;
1303     }
1304
1305   while (header_len > 0)
1306     {
1307       if ((len = write (fd, hp, header_len)) < 0)
1308         {
1309           err = ctf_set_errno (fp, errno);
1310           ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing header"));
1311           goto ret;
1312         }
1313       header_len -= len;
1314       hp += len;
1315     }
1316
1317   bp = buf;
1318   while (compress_len > 0)
1319     {
1320       if ((len = write (fd, bp, compress_len)) < 0)
1321         {
1322           err = ctf_set_errno (fp, errno);
1323           ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing"));
1324           goto ret;
1325         }
1326       compress_len -= len;
1327       bp += len;
1328     }
1329
1330 ret:
1331   free (buf);
1332   return err;
1333 }
1334
1335 /* Optionally compress the specified CTF data stream and return it as a new
1336    dynamically-allocated string.  */
1337 unsigned char *
1338 ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
1339 {
1340   unsigned char *buf;
1341   unsigned char *bp;
1342   ctf_header_t *hp;
1343   ssize_t header_len = sizeof (ctf_header_t);
1344   ssize_t compress_len;
1345   int rc;
1346
1347   if (ctf_serialize (fp) < 0)
1348     return NULL;                                /* errno is set for us.  */
1349
1350   compress_len = compressBound (fp->ctf_size);
1351   if (fp->ctf_size < threshold)
1352     compress_len = fp->ctf_size;
1353   if ((buf = malloc (compress_len
1354                      + sizeof (struct ctf_header))) == NULL)
1355     {
1356       ctf_set_errno (fp, ENOMEM);
1357       ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
1358                     (unsigned long) (compress_len + sizeof (struct ctf_header)));
1359       return NULL;
1360     }
1361
1362   hp = (ctf_header_t *) buf;
1363   memcpy (hp, fp->ctf_header, header_len);
1364   bp = buf + sizeof (struct ctf_header);
1365   *size = sizeof (struct ctf_header);
1366
1367   if (fp->ctf_size < threshold)
1368     {
1369       hp->cth_flags &= ~CTF_F_COMPRESS;
1370       memcpy (bp, fp->ctf_buf, fp->ctf_size);
1371       *size += fp->ctf_size;
1372     }
1373   else
1374     {
1375       hp->cth_flags |= CTF_F_COMPRESS;
1376       if ((rc = compress (bp, (uLongf *) &compress_len,
1377                           fp->ctf_buf, fp->ctf_size)) != Z_OK)
1378         {
1379           ctf_set_errno (fp, ECTF_COMPRESS);
1380           ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
1381           free (buf);
1382           return NULL;
1383         }
1384       *size += compress_len;
1385     }
1386   return buf;
1387 }
1388
1389 /* Write the uncompressed CTF data stream to the specified file descriptor.  */
1390 int
1391 ctf_write (ctf_dict_t *fp, int fd)
1392 {
1393   const unsigned char *buf;
1394   ssize_t resid;
1395   ssize_t len;
1396
1397   if (ctf_serialize (fp) < 0)
1398     return -1;                                  /* errno is set for us.  */
1399
1400   resid = sizeof (ctf_header_t);
1401   buf = (unsigned char *) fp->ctf_header;
1402   while (resid != 0)
1403     {
1404       if ((len = write (fd, buf, resid)) <= 0)
1405         {
1406           ctf_err_warn (fp, 0, errno, _("ctf_write: error writing header"));
1407           return (ctf_set_errno (fp, errno));
1408         }
1409       resid -= len;
1410       buf += len;
1411     }
1412
1413   resid = fp->ctf_size;
1414   buf = fp->ctf_buf;
1415   while (resid != 0)
1416     {
1417       if ((len = write (fd, buf, resid)) <= 0)
1418         {
1419           ctf_err_warn (fp, 0, errno, _("ctf_write: error writing"));
1420           return (ctf_set_errno (fp, errno));
1421         }
1422       resid -= len;
1423       buf += len;
1424     }
1425
1426   return 0;
1427 }