libctf/ctf-create.c

   1 /* CTF file creation.
   2    Copyright (C) 2019-2020 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 <sys/param.h>
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <zlib.h>
  26
  27 #ifndef roundup
  28 #define roundup(x, y)  ((((x) + ((y) - 1)) / (y)) * (y))
  29 #endif
  30
  31 /* Make sure the ptrtab has enough space for at least one more type.
  32
  33    We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
  34    at a time.  */
  35
  36 static int
  37 ctf_grow_ptrtab (ctf_file_t *fp)
  38 {
  39   size_t new_ptrtab_len = fp->ctf_ptrtab_len;
  40
  41   /* We allocate one more ptrtab entry than we need, for the initial zero,
  42      plus one because the caller will probably allocate a new type.  */
  43
  44   if (fp->ctf_ptrtab == NULL)
  45     new_ptrtab_len = 1024;
  46   else if ((fp->ctf_typemax + 2) > fp->ctf_ptrtab_len)
  47     new_ptrtab_len = fp->ctf_ptrtab_len * 1.25;
  48
  49   if (new_ptrtab_len != fp->ctf_ptrtab_len)
  50     {
  51       uint32_t *new_ptrtab;
  52
  53       if ((new_ptrtab = realloc (fp->ctf_ptrtab,
  54                                  new_ptrtab_len * sizeof (uint32_t))) == NULL)
  55         return (ctf_set_errno (fp, ENOMEM));
  56
  57       fp->ctf_ptrtab = new_ptrtab;
  58       memset (fp->ctf_ptrtab + fp->ctf_ptrtab_len, 0,
  59               (new_ptrtab_len - fp->ctf_ptrtab_len) * sizeof (uint32_t));
  60       fp->ctf_ptrtab_len = new_ptrtab_len;
  61     }
  62   return 0;
  63 }
  64
  65 /* To create an empty CTF container, we just declare a zeroed header and call
  66    ctf_bufopen() on it.  If ctf_bufopen succeeds, we mark the new container r/w
  67    and initialize the dynamic members.  We start assigning type IDs at 1 because
  68    type ID 0 is used as a sentinel and a not-found indicator.  */
  69
  70 ctf_file_t *
  71 ctf_create (int *errp)
  72 {
  73   static const ctf_header_t hdr = { .cth_preamble = { CTF_MAGIC, CTF_VERSION, 0 } };
  74
  75   ctf_dynhash_t *dthash;
  76   ctf_dynhash_t *dvhash;
  77   ctf_dynhash_t *structs = NULL, *unions = NULL, *enums = NULL, *names = NULL;
  78   ctf_sect_t cts;
  79   ctf_file_t *fp;
  80
  81   libctf_init_debug();
  82   dthash = ctf_dynhash_create (ctf_hash_integer, ctf_hash_eq_integer,
  83                                NULL, NULL);
  84   if (dthash == NULL)
  85     {
  86       ctf_set_open_errno (errp, EAGAIN);
  87       goto err;
  88     }
  89
  90   dvhash = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
  91                                NULL, NULL);
  92   if (dvhash == NULL)
  93     {
  94       ctf_set_open_errno (errp, EAGAIN);
  95       goto err_dt;
  96     }
  97
  98   structs = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
  99                                 NULL, NULL);
 100   unions = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
 101                                NULL, NULL);
 102   enums = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
 103                               NULL, NULL);
 104   names = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
 105                               NULL, NULL);
 106   if (!structs || !unions || !enums || !names)
 107     {
 108       ctf_set_open_errno (errp, EAGAIN);
 109       goto err_dv;
 110     }
 111
 112   cts.cts_name = _CTF_SECTION;
 113   cts.cts_data = &hdr;
 114   cts.cts_size = sizeof (hdr);
 115   cts.cts_entsize = 1;
 116
 117   if ((fp = ctf_bufopen_internal (&cts, NULL, NULL, NULL, 1, errp)) == NULL)
 118     goto err_dv;
 119
 120   fp->ctf_structs.ctn_writable = structs;
 121   fp->ctf_unions.ctn_writable = unions;
 122   fp->ctf_enums.ctn_writable = enums;
 123   fp->ctf_names.ctn_writable = names;
 124   fp->ctf_dthash = dthash;
 125   fp->ctf_dvhash = dvhash;
 126   fp->ctf_dtoldid = 0;
 127   fp->ctf_snapshots = 1;
 128   fp->ctf_snapshot_lu = 0;
 129   fp->ctf_flags |= LCTF_DIRTY;
 130
 131   ctf_set_ctl_hashes (fp);
 132   ctf_setmodel (fp, CTF_MODEL_NATIVE);
 133   if (ctf_grow_ptrtab (fp) < 0)
 134     {
 135       ctf_set_open_errno (errp, ctf_errno (fp));
 136       ctf_file_close (fp);
 137       return NULL;
 138     }
 139
 140   return fp;
 141
 142  err_dv:
 143   ctf_dynhash_destroy (structs);
 144   ctf_dynhash_destroy (unions);
 145   ctf_dynhash_destroy (enums);
 146   ctf_dynhash_destroy (names);
 147   ctf_dynhash_destroy (dvhash);
 148  err_dt:
 149   ctf_dynhash_destroy (dthash);
 150  err:
 151   return NULL;
 152 }
 153
 154 static unsigned char *
 155 ctf_copy_smembers (ctf_file_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 156 {
 157   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 158   ctf_member_t ctm;
 159
 160   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 161     {
 162       ctf_member_t *copied;
 163
 164       ctm.ctm_name = 0;
 165       ctm.ctm_type = (uint32_t) dmd->dmd_type;
 166       ctm.ctm_offset = (uint32_t) dmd->dmd_offset;
 167
 168       memcpy (t, &ctm, sizeof (ctm));
 169       copied = (ctf_member_t *) t;
 170       if (dmd->dmd_name)
 171         ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctm_name);
 172
 173       t += sizeof (ctm);
 174     }
 175
 176   return t;
 177 }
 178
 179 static unsigned char *
 180 ctf_copy_lmembers (ctf_file_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 181 {
 182   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 183   ctf_lmember_t ctlm;
 184
 185   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 186     {
 187       ctf_lmember_t *copied;
 188
 189       ctlm.ctlm_name = 0;
 190       ctlm.ctlm_type = (uint32_t) dmd->dmd_type;
 191       ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset);
 192       ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset);
 193
 194       memcpy (t, &ctlm, sizeof (ctlm));
 195       copied = (ctf_lmember_t *) t;
 196       if (dmd->dmd_name)
 197         ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctlm_name);
 198
 199       t += sizeof (ctlm);
 200     }
 201
 202   return t;
 203 }
 204
 205 static unsigned char *
 206 ctf_copy_emembers (ctf_file_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
 207 {
 208   ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 209   ctf_enum_t cte;
 210
 211   for (; dmd != NULL; dmd = ctf_list_next (dmd))
 212     {
 213       ctf_enum_t *copied;
 214
 215       cte.cte_value = dmd->dmd_value;
 216       memcpy (t, &cte, sizeof (cte));
 217       copied = (ctf_enum_t *) t;
 218       ctf_str_add_ref (fp, dmd->dmd_name, &copied->cte_name);
 219       t += sizeof (cte);
 220     }
 221
 222   return t;
 223 }
 224
 225 /* Sort a newly-constructed static variable array.  */
 226
 227 typedef struct ctf_sort_var_arg_cb
 228 {
 229   ctf_file_t *fp;
 230   ctf_strs_t *strtab;
 231 } ctf_sort_var_arg_cb_t;
 232
 233 static int
 234 ctf_sort_var (const void *one_, const void *two_, void *arg_)
 235 {
 236   const ctf_varent_t *one = one_;
 237   const ctf_varent_t *two = two_;
 238   ctf_sort_var_arg_cb_t *arg = arg_;
 239
 240   return (strcmp (ctf_strraw_explicit (arg->fp, one->ctv_name, arg->strtab),
 241                   ctf_strraw_explicit (arg->fp, two->ctv_name, arg->strtab)));
 242 }
 243
 244 /* Compatibility: just update the threshold for ctf_discard.  */
 245 int
 246 ctf_update (ctf_file_t *fp)
 247 {
 248   if (!(fp->ctf_flags & LCTF_RDWR))
 249     return (ctf_set_errno (fp, ECTF_RDONLY));
 250
 251   fp->ctf_dtoldid = fp->ctf_typemax;
 252   return 0;
 253 }
 254
 255 /* If the specified CTF container is writable and has been modified, reload this
 256    container with the updated type definitions, ready for serialization.  In
 257    order to make this code and the rest of libctf as simple as possible, we
 258    perform updates by taking the dynamic type definitions and creating an
 259    in-memory CTF file containing the definitions, and then call
 260    ctf_simple_open_internal() on it.  We perform one extra trick here for the
 261    benefit of callers and to keep our code simple: ctf_simple_open_internal()
 262    will return a new ctf_file_t, but we want to keep the fp constant for the
 263    caller, so after ctf_simple_open_internal() returns, we use memcpy to swap
 264    the interior of the old and new ctf_file_t's, and then free the old.  */
 265 int
 266 ctf_serialize (ctf_file_t *fp)
 267 {
 268   ctf_file_t ofp, *nfp;
 269   ctf_header_t hdr, *hdrp;
 270   ctf_dtdef_t *dtd;
 271   ctf_dvdef_t *dvd;
 272   ctf_varent_t *dvarents;
 273   ctf_strs_writable_t strtab;
 274
 275   unsigned char *t;
 276   unsigned long i;
 277   size_t buf_size, type_size, nvars;
 278   unsigned char *buf, *newbuf;
 279   int err;
 280
 281   if (!(fp->ctf_flags & LCTF_RDWR))
 282     return (ctf_set_errno (fp, ECTF_RDONLY));
 283
 284   /* Update required?  */
 285   if (!(fp->ctf_flags & LCTF_DIRTY))
 286     return 0;
 287
 288   /* Fill in an initial CTF header.  We will leave the label, object,
 289      and function sections empty and only output a header, type section,
 290      and string table.  The type section begins at a 4-byte aligned
 291      boundary past the CTF header itself (at relative offset zero).  */
 292
 293   memset (&hdr, 0, sizeof (hdr));
 294   hdr.cth_magic = CTF_MAGIC;
 295   hdr.cth_version = CTF_VERSION;
 296
 297   /* Iterate through the dynamic type definition list and compute the
 298      size of the CTF type section we will need to generate.  */
 299
 300   for (type_size = 0, dtd = ctf_list_next (&fp->ctf_dtdefs);
 301        dtd != NULL; dtd = ctf_list_next (dtd))
 302     {
 303       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 304       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 305
 306       if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
 307         type_size += sizeof (ctf_stype_t);
 308       else
 309         type_size += sizeof (ctf_type_t);
 310
 311       switch (kind)
 312         {
 313         case CTF_K_INTEGER:
 314         case CTF_K_FLOAT:
 315           type_size += sizeof (uint32_t);
 316           break;
 317         case CTF_K_ARRAY:
 318           type_size += sizeof (ctf_array_t);
 319           break;
 320         case CTF_K_SLICE:
 321           type_size += sizeof (ctf_slice_t);
 322           break;
 323         case CTF_K_FUNCTION:
 324           type_size += sizeof (uint32_t) * (vlen + (vlen & 1));
 325           break;
 326         case CTF_K_STRUCT:
 327         case CTF_K_UNION:
 328           if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
 329             type_size += sizeof (ctf_member_t) * vlen;
 330           else
 331             type_size += sizeof (ctf_lmember_t) * vlen;
 332           break;
 333         case CTF_K_ENUM:
 334           type_size += sizeof (ctf_enum_t) * vlen;
 335           break;
 336         }
 337     }
 338
 339   /* Computing the number of entries in the CTF variable section is much
 340      simpler.  */
 341
 342   for (nvars = 0, dvd = ctf_list_next (&fp->ctf_dvdefs);
 343        dvd != NULL; dvd = ctf_list_next (dvd), nvars++);
 344
 345   /* Compute the size of the CTF buffer we need, sans only the string table,
 346      then allocate a new buffer and memcpy the finished header to the start of
 347      the buffer.  (We will adjust this later with strtab length info.)  */
 348
 349   hdr.cth_typeoff = hdr.cth_varoff + (nvars * sizeof (ctf_varent_t));
 350   hdr.cth_stroff = hdr.cth_typeoff + type_size;
 351   hdr.cth_strlen = 0;
 352
 353   buf_size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
 354
 355   if ((buf = malloc (buf_size)) == NULL)
 356     return (ctf_set_errno (fp, EAGAIN));
 357
 358   memcpy (buf, &hdr, sizeof (ctf_header_t));
 359   t = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_varoff;
 360
 361   hdrp = (ctf_header_t *) buf;
 362   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parname != NULL))
 363     ctf_str_add_ref (fp, fp->ctf_parname, &hdrp->cth_parname);
 364   if (fp->ctf_cuname != NULL)
 365     ctf_str_add_ref (fp, fp->ctf_cuname, &hdrp->cth_cuname);
 366
 367   /* Work over the variable list, translating everything into ctf_varent_t's and
 368      prepping the string table.  */
 369
 370   dvarents = (ctf_varent_t *) t;
 371   for (i = 0, dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
 372        dvd = ctf_list_next (dvd), i++)
 373     {
 374       ctf_varent_t *var = &dvarents[i];
 375
 376       ctf_str_add_ref (fp, dvd->dvd_name, &var->ctv_name);
 377       var->ctv_type = (uint32_t) dvd->dvd_type;
 378     }
 379   assert (i == nvars);
 380
 381   t += sizeof (ctf_varent_t) * nvars;
 382
 383   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_typeoff);
 384
 385   /* We now take a final lap through the dynamic type definition list and copy
 386      the appropriate type records to the output buffer, noting down the
 387      strings as we go.  */
 388
 389   for (dtd = ctf_list_next (&fp->ctf_dtdefs);
 390        dtd != NULL; dtd = ctf_list_next (dtd))
 391     {
 392       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 393       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 394
 395       ctf_array_t cta;
 396       uint32_t encoding;
 397       size_t len;
 398       ctf_stype_t *copied;
 399       const char *name;
 400
 401       if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
 402         len = sizeof (ctf_stype_t);
 403       else
 404         len = sizeof (ctf_type_t);
 405
 406       memcpy (t, &dtd->dtd_data, len);
 407       copied = (ctf_stype_t *) t;  /* name is at the start: constant offset.  */
 408       if (copied->ctt_name
 409           && (name = ctf_strraw (fp, copied->ctt_name)) != NULL)
 410         ctf_str_add_ref (fp, name, &copied->ctt_name);
 411       t += len;
 412
 413       switch (kind)
 414         {
 415         case CTF_K_INTEGER:
 416         case CTF_K_FLOAT:
 417           if (kind == CTF_K_INTEGER)
 418             {
 419               encoding = CTF_INT_DATA (dtd->dtd_u.dtu_enc.cte_format,
 420                                        dtd->dtd_u.dtu_enc.cte_offset,
 421                                        dtd->dtd_u.dtu_enc.cte_bits);
 422             }
 423           else
 424             {
 425               encoding = CTF_FP_DATA (dtd->dtd_u.dtu_enc.cte_format,
 426                                       dtd->dtd_u.dtu_enc.cte_offset,
 427                                       dtd->dtd_u.dtu_enc.cte_bits);
 428             }
 429           memcpy (t, &encoding, sizeof (encoding));
 430           t += sizeof (encoding);
 431           break;
 432
 433         case CTF_K_SLICE:
 434           memcpy (t, &dtd->dtd_u.dtu_slice, sizeof (struct ctf_slice));
 435           t += sizeof (struct ctf_slice);
 436           break;
 437
 438         case CTF_K_ARRAY:
 439           cta.cta_contents = (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents;
 440           cta.cta_index = (uint32_t) dtd->dtd_u.dtu_arr.ctr_index;
 441           cta.cta_nelems = dtd->dtd_u.dtu_arr.ctr_nelems;
 442           memcpy (t, &cta, sizeof (cta));
 443           t += sizeof (cta);
 444           break;
 445
 446         case CTF_K_FUNCTION:
 447           {
 448             uint32_t *argv = (uint32_t *) (uintptr_t) t;
 449             uint32_t argc;
 450
 451             for (argc = 0; argc < vlen; argc++)
 452               *argv++ = dtd->dtd_u.dtu_argv[argc];
 453
 454             if (vlen & 1)
 455               *argv++ = 0;      /* Pad to 4-byte boundary.  */
 456
 457             t = (unsigned char *) argv;
 458             break;
 459           }
 460
 461         case CTF_K_STRUCT:
 462         case CTF_K_UNION:
 463           if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
 464             t = ctf_copy_smembers (fp, dtd, t);
 465           else
 466             t = ctf_copy_lmembers (fp, dtd, t);
 467           break;
 468
 469         case CTF_K_ENUM:
 470           t = ctf_copy_emembers (fp, dtd, t);
 471           break;
 472         }
 473     }
 474   assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff);
 475
 476   /* Construct the final string table and fill out all the string refs with the
 477      final offsets.  Then purge the refs list, because we're about to move this
 478      strtab onto the end of the buf, invalidating all the offsets.  */
 479   strtab = ctf_str_write_strtab (fp);
 480   ctf_str_purge_refs (fp);
 481
 482   if (strtab.cts_strs == NULL)
 483     {
 484       free (buf);
 485       return (ctf_set_errno (fp, EAGAIN));
 486     }
 487
 488   /* Now the string table is constructed, we can sort the buffer of
 489      ctf_varent_t's.  */
 490   ctf_sort_var_arg_cb_t sort_var_arg = { fp, (ctf_strs_t *) &strtab };
 491   ctf_qsort_r (dvarents, nvars, sizeof (ctf_varent_t), ctf_sort_var,
 492                &sort_var_arg);
 493
 494   if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
 495     {
 496       free (buf);
 497       free (strtab.cts_strs);
 498       return (ctf_set_errno (fp, EAGAIN));
 499     }
 500   buf = newbuf;
 501   memcpy (buf + buf_size, strtab.cts_strs, strtab.cts_len);
 502   hdrp = (ctf_header_t *) buf;
 503   hdrp->cth_strlen = strtab.cts_len;
 504   buf_size += hdrp->cth_strlen;
 505   free (strtab.cts_strs);
 506
 507   /* Finally, we are ready to ctf_simple_open() the new container.  If this
 508      is successful, we then switch nfp and fp and free the old container.  */
 509
 510   if ((nfp = ctf_simple_open_internal ((char *) buf, buf_size, NULL, 0,
 511                                        0, NULL, 0, fp->ctf_syn_ext_strtab,
 512                                        1, &err)) == NULL)
 513     {
 514       free (buf);
 515       return (ctf_set_errno (fp, err));
 516     }
 517
 518   (void) ctf_setmodel (nfp, ctf_getmodel (fp));
 519
 520   nfp->ctf_parent = fp->ctf_parent;
 521   nfp->ctf_parent_unreffed = fp->ctf_parent_unreffed;
 522   nfp->ctf_refcnt = fp->ctf_refcnt;
 523   nfp->ctf_flags |= fp->ctf_flags & ~LCTF_DIRTY;
 524   if (nfp->ctf_dynbase == NULL)
 525     nfp->ctf_dynbase = buf;             /* Make sure buf is freed on close.  */
 526   nfp->ctf_dthash = fp->ctf_dthash;
 527   nfp->ctf_dtdefs = fp->ctf_dtdefs;
 528   nfp->ctf_dvhash = fp->ctf_dvhash;
 529   nfp->ctf_dvdefs = fp->ctf_dvdefs;
 530   nfp->ctf_dtoldid = fp->ctf_dtoldid;
 531   nfp->ctf_add_processing = fp->ctf_add_processing;
 532   nfp->ctf_snapshots = fp->ctf_snapshots + 1;
 533   nfp->ctf_specific = fp->ctf_specific;
 534   nfp->ctf_ptrtab = fp->ctf_ptrtab;
 535   nfp->ctf_ptrtab_len = fp->ctf_ptrtab_len;
 536   nfp->ctf_link_inputs = fp->ctf_link_inputs;
 537   nfp->ctf_link_outputs = fp->ctf_link_outputs;
 538   nfp->ctf_errs_warnings = fp->ctf_errs_warnings;
 539   nfp->ctf_str_prov_offset = fp->ctf_str_prov_offset;
 540   nfp->ctf_syn_ext_strtab = fp->ctf_syn_ext_strtab;
 541   nfp->ctf_link_cu_mapping = fp->ctf_link_cu_mapping;
 542   nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
 543   nfp->ctf_link_memb_name_changer = fp->ctf_link_memb_name_changer;
 544   nfp->ctf_link_memb_name_changer_arg = fp->ctf_link_memb_name_changer_arg;
 545   nfp->ctf_link_flags = fp->ctf_link_flags;
 546
 547   nfp->ctf_snapshot_lu = fp->ctf_snapshots;
 548
 549   memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
 550   nfp->ctf_structs = fp->ctf_structs;
 551   nfp->ctf_unions = fp->ctf_unions;
 552   nfp->ctf_enums = fp->ctf_enums;
 553   nfp->ctf_names = fp->ctf_names;
 554
 555   fp->ctf_dthash = NULL;
 556   ctf_str_free_atoms (nfp);
 557   nfp->ctf_str_atoms = fp->ctf_str_atoms;
 558   nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
 559   fp->ctf_str_atoms = NULL;
 560   fp->ctf_prov_strtab = NULL;
 561   memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
 562   memset (&fp->ctf_errs_warnings, 0, sizeof (ctf_list_t));
 563   fp->ctf_add_processing = NULL;
 564   fp->ctf_ptrtab = NULL;
 565   fp->ctf_link_inputs = NULL;
 566   fp->ctf_link_outputs = NULL;
 567   fp->ctf_syn_ext_strtab = NULL;
 568   fp->ctf_link_cu_mapping = NULL;
 569   fp->ctf_link_type_mapping = NULL;
 570   fp->ctf_parent_unreffed = 1;
 571
 572   fp->ctf_dvhash = NULL;
 573   memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
 574   memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
 575   fp->ctf_structs.ctn_writable = NULL;
 576   fp->ctf_unions.ctn_writable = NULL;
 577   fp->ctf_enums.ctn_writable = NULL;
 578   fp->ctf_names.ctn_writable = NULL;
 579
 580   memcpy (&ofp, fp, sizeof (ctf_file_t));
 581   memcpy (fp, nfp, sizeof (ctf_file_t));
 582   memcpy (nfp, &ofp, sizeof (ctf_file_t));
 583
 584   nfp->ctf_refcnt = 1;          /* Force nfp to be freed.  */
 585   ctf_file_close (nfp);
 586
 587   return 0;
 588 }
 589
 590 ctf_names_t *
 591 ctf_name_table (ctf_file_t *fp, int kind)
 592 {
 593   switch (kind)
 594     {
 595     case CTF_K_STRUCT:
 596       return &fp->ctf_structs;
 597     case CTF_K_UNION:
 598       return &fp->ctf_unions;
 599     case CTF_K_ENUM:
 600       return &fp->ctf_enums;
 601     default:
 602       return &fp->ctf_names;
 603     }
 604 }
 605
 606 int
 607 ctf_dtd_insert (ctf_file_t *fp, ctf_dtdef_t *dtd, int flag, int kind)
 608 {
 609   const char *name;
 610   if (ctf_dynhash_insert (fp->ctf_dthash, (void *) dtd->dtd_type, dtd) < 0)
 611     return -1;
 612
 613   if (flag == CTF_ADD_ROOT && dtd->dtd_data.ctt_name
 614       && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
 615     {
 616       if (ctf_dynhash_insert (ctf_name_table (fp, kind)->ctn_writable,
 617                               (char *) name, (void *) dtd->dtd_type) < 0)
 618         {
 619           ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 620           return -1;
 621         }
 622     }
 623   ctf_list_append (&fp->ctf_dtdefs, dtd);
 624   return 0;
 625 }
 626
 627 void
 628 ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
 629 {
 630   ctf_dmdef_t *dmd, *nmd;
 631   int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 632   int name_kind = kind;
 633   const char *name;
 634
 635   ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 636
 637   switch (kind)
 638     {
 639     case CTF_K_STRUCT:
 640     case CTF_K_UNION:
 641     case CTF_K_ENUM:
 642       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 643            dmd != NULL; dmd = nmd)
 644         {
 645           if (dmd->dmd_name != NULL)
 646               free (dmd->dmd_name);
 647           nmd = ctf_list_next (dmd);
 648           free (dmd);
 649         }
 650       break;
 651     case CTF_K_FUNCTION:
 652       free (dtd->dtd_u.dtu_argv);
 653       break;
 654     case CTF_K_FORWARD:
 655       name_kind = dtd->dtd_data.ctt_type;
 656       break;
 657     }
 658
 659   if (dtd->dtd_data.ctt_name
 660       && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL
 661       && LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info))
 662     {
 663       ctf_dynhash_remove (ctf_name_table (fp, name_kind)->ctn_writable,
 664                           name);
 665       ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
 666     }
 667
 668   ctf_list_delete (&fp->ctf_dtdefs, dtd);
 669   free (dtd);
 670 }
 671
 672 ctf_dtdef_t *
 673 ctf_dtd_lookup (const ctf_file_t *fp, ctf_id_t type)
 674 {
 675   return (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dthash, (void *) type);
 676 }
 677
 678 ctf_dtdef_t *
 679 ctf_dynamic_type (const ctf_file_t *fp, ctf_id_t id)
 680 {
 681   ctf_id_t idx;
 682
 683   if (!(fp->ctf_flags & LCTF_RDWR))
 684     return NULL;
 685
 686   if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, id))
 687     fp = fp->ctf_parent;
 688
 689   idx = LCTF_TYPE_TO_INDEX(fp, id);
 690
 691   if ((unsigned long) idx <= fp->ctf_typemax)
 692     return ctf_dtd_lookup (fp, id);
 693   return NULL;
 694 }
 695
 696 int
 697 ctf_dvd_insert (ctf_file_t *fp, ctf_dvdef_t *dvd)
 698 {
 699   if (ctf_dynhash_insert (fp->ctf_dvhash, dvd->dvd_name, dvd) < 0)
 700     return -1;
 701   ctf_list_append (&fp->ctf_dvdefs, dvd);
 702   return 0;
 703 }
 704
 705 void
 706 ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
 707 {
 708   ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name);
 709   free (dvd->dvd_name);
 710
 711   ctf_list_delete (&fp->ctf_dvdefs, dvd);
 712   free (dvd);
 713 }
 714
 715 ctf_dvdef_t *
 716 ctf_dvd_lookup (const ctf_file_t *fp, const char *name)
 717 {
 718   return (ctf_dvdef_t *) ctf_dynhash_lookup (fp->ctf_dvhash, name);
 719 }
 720
 721 /* Discard all of the dynamic type definitions and variable definitions that
 722    have been added to the container since the last call to ctf_update().  We
 723    locate such types by scanning the dtd list and deleting elements that have
 724    type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
 725    by scanning the variable list and deleting elements that have update IDs
 726    equal to the current value of the last-update snapshot count (indicating that
 727    they were added after the most recent call to ctf_update()).  */
 728 int
 729 ctf_discard (ctf_file_t *fp)
 730 {
 731   ctf_snapshot_id_t last_update =
 732     { fp->ctf_dtoldid,
 733       fp->ctf_snapshot_lu + 1 };
 734
 735   /* Update required?  */
 736   if (!(fp->ctf_flags & LCTF_DIRTY))
 737     return 0;
 738
 739   return (ctf_rollback (fp, last_update));
 740 }
 741
 742 ctf_snapshot_id_t
 743 ctf_snapshot (ctf_file_t *fp)
 744 {
 745   ctf_snapshot_id_t snapid;
 746   snapid.dtd_id = fp->ctf_typemax;
 747   snapid.snapshot_id = fp->ctf_snapshots++;
 748   return snapid;
 749 }
 750
 751 /* Like ctf_discard(), only discards everything after a particular ID.  */
 752 int
 753 ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
 754 {
 755   ctf_dtdef_t *dtd, *ntd;
 756   ctf_dvdef_t *dvd, *nvd;
 757
 758   if (!(fp->ctf_flags & LCTF_RDWR))
 759     return (ctf_set_errno (fp, ECTF_RDONLY));
 760
 761   if (fp->ctf_snapshot_lu >= id.snapshot_id)
 762     return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
 763
 764   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
 765     {
 766       int kind;
 767       const char *name;
 768
 769       ntd = ctf_list_next (dtd);
 770
 771       if (LCTF_TYPE_TO_INDEX (fp, dtd->dtd_type) <= id.dtd_id)
 772         continue;
 773
 774       kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 775       if (kind == CTF_K_FORWARD)
 776         kind = dtd->dtd_data.ctt_type;
 777
 778       if (dtd->dtd_data.ctt_name
 779           && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL
 780           && LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info))
 781         {
 782           ctf_dynhash_remove (ctf_name_table (fp, kind)->ctn_writable,
 783                               name);
 784           ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
 785         }
 786
 787       ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 788       ctf_dtd_delete (fp, dtd);
 789     }
 790
 791   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
 792     {
 793       nvd = ctf_list_next (dvd);
 794
 795       if (dvd->dvd_snapshots <= id.snapshot_id)
 796         continue;
 797
 798       ctf_dvd_delete (fp, dvd);
 799     }
 800
 801   fp->ctf_typemax = id.dtd_id;
 802   fp->ctf_snapshots = id.snapshot_id;
 803
 804   if (fp->ctf_snapshots == fp->ctf_snapshot_lu)
 805     fp->ctf_flags &= ~LCTF_DIRTY;
 806
 807   return 0;
 808 }
 809
 810 static ctf_id_t
 811 ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
 812                  ctf_dtdef_t **rp)
 813 {
 814   ctf_dtdef_t *dtd;
 815   ctf_id_t type;
 816
 817   if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
 818     return (ctf_set_errno (fp, EINVAL));
 819
 820   if (!(fp->ctf_flags & LCTF_RDWR))
 821     return (ctf_set_errno (fp, ECTF_RDONLY));
 822
 823   if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) >= CTF_MAX_TYPE)
 824     return (ctf_set_errno (fp, ECTF_FULL));
 825
 826   if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) == (CTF_MAX_PTYPE - 1))
 827     return (ctf_set_errno (fp, ECTF_FULL));
 828
 829   /* Make sure ptrtab always grows to be big enough for all types.  */
 830   if (ctf_grow_ptrtab (fp) < 0)
 831       return CTF_ERR;           /* errno is set for us. */
 832
 833   if ((dtd = malloc (sizeof (ctf_dtdef_t))) == NULL)
 834     return (ctf_set_errno (fp, EAGAIN));
 835
 836   type = ++fp->ctf_typemax;
 837   type = LCTF_INDEX_TO_TYPE (fp, type, (fp->ctf_flags & LCTF_CHILD));
 838
 839   memset (dtd, 0, sizeof (ctf_dtdef_t));
 840   dtd->dtd_data.ctt_name = ctf_str_add_ref (fp, name, &dtd->dtd_data.ctt_name);
 841   dtd->dtd_type = type;
 842
 843   if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
 844     {
 845       free (dtd);
 846       return (ctf_set_errno (fp, EAGAIN));
 847     }
 848
 849   if (ctf_dtd_insert (fp, dtd, flag, kind) < 0)
 850     {
 851       free (dtd);
 852       return CTF_ERR;                   /* errno is set for us.  */
 853     }
 854   fp->ctf_flags |= LCTF_DIRTY;
 855
 856   *rp = dtd;
 857   return type;
 858 }
 859
 860 /* When encoding integer sizes, we want to convert a byte count in the range
 861    1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc).  The clp2() function
 862    is a clever implementation from "Hacker's Delight" by Henry Warren, Jr.  */
 863 static size_t
 864 clp2 (size_t x)
 865 {
 866   x--;
 867
 868   x |= (x >> 1);
 869   x |= (x >> 2);
 870   x |= (x >> 4);
 871   x |= (x >> 8);
 872   x |= (x >> 16);
 873
 874   return (x + 1);
 875 }
 876
 877 static ctf_id_t
 878 ctf_add_encoded (ctf_file_t *fp, uint32_t flag,
 879                  const char *name, const ctf_encoding_t *ep, uint32_t kind)
 880 {
 881   ctf_dtdef_t *dtd;
 882   ctf_id_t type;
 883
 884   if (ep == NULL)
 885     return (ctf_set_errno (fp, EINVAL));
 886
 887   if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
 888     return CTF_ERR;             /* errno is set for us.  */
 889
 890   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
 891   dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
 892                                  / CHAR_BIT);
 893   dtd->dtd_u.dtu_enc = *ep;
 894
 895   return type;
 896 }
 897
 898 static ctf_id_t
 899 ctf_add_reftype (ctf_file_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
 900 {
 901   ctf_dtdef_t *dtd;
 902   ctf_id_t type;
 903   ctf_file_t *tmp = fp;
 904   int child = fp->ctf_flags & LCTF_CHILD;
 905
 906   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
 907     return (ctf_set_errno (fp, EINVAL));
 908
 909   if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
 910     return CTF_ERR;             /* errno is set for us.  */
 911
 912   if ((type = ctf_add_generic (fp, flag, NULL, kind, &dtd)) == CTF_ERR)
 913     return CTF_ERR;             /* errno is set for us.  */
 914
 915   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
 916   dtd->dtd_data.ctt_type = (uint32_t) ref;
 917
 918   if (kind != CTF_K_POINTER)
 919     return type;
 920
 921   /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
 922      type and (if an anonymous typedef node is being pointed at) the type that
 923      points at too.  Note that ctf_typemax is at this point one higher than we
 924      want to check against, because it's just been incremented for the addition
 925      of this type.  */
 926
 927   uint32_t type_idx = LCTF_TYPE_TO_INDEX (fp, type);
 928   uint32_t ref_idx = LCTF_TYPE_TO_INDEX (fp, ref);
 929
 930   if (LCTF_TYPE_ISCHILD (fp, ref) == child
 931       && ref_idx < fp->ctf_typemax)
 932     {
 933       fp->ctf_ptrtab[ref_idx] = type_idx;
 934
 935       ctf_id_t refref_idx = LCTF_TYPE_TO_INDEX (fp, dtd->dtd_data.ctt_type);
 936
 937       if (tmp == fp
 938           && (LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) == CTF_K_TYPEDEF)
 939           && strcmp (ctf_strptr (fp, dtd->dtd_data.ctt_name), "") == 0
 940           && refref_idx < fp->ctf_typemax)
 941         fp->ctf_ptrtab[refref_idx] = type_idx;
 942     }
 943
 944   return type;
 945 }
 946
 947 ctf_id_t
 948 ctf_add_slice (ctf_file_t *fp, uint32_t flag, ctf_id_t ref,
 949                const ctf_encoding_t *ep)
 950 {
 951   ctf_dtdef_t *dtd;
 952   ctf_id_t resolved_ref = ref;
 953   ctf_id_t type;
 954   int kind;
 955   const ctf_type_t *tp;
 956   ctf_file_t *tmp = fp;
 957
 958   if (ep == NULL)
 959     return (ctf_set_errno (fp, EINVAL));
 960
 961   if ((ep->cte_bits > 255) || (ep->cte_offset > 255))
 962     return (ctf_set_errno (fp, ECTF_SLICEOVERFLOW));
 963
 964   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
 965     return (ctf_set_errno (fp, EINVAL));
 966
 967   if (ref != 0 && ((tp = ctf_lookup_by_id (&tmp, ref)) == NULL))
 968     return CTF_ERR;             /* errno is set for us.  */
 969
 970   /* Make sure we ultimately point to an integral type.  We also allow slices to
 971      point to the unimplemented type, for now, because the compiler can emit
 972      such slices, though they're not very much use.  */
 973
 974   resolved_ref = ctf_type_resolve_unsliced (tmp, ref);
 975   kind = ctf_type_kind_unsliced (tmp, resolved_ref);
 976
 977   if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) &&
 978       (kind != CTF_K_ENUM)
 979       && (ref != 0))
 980     return (ctf_set_errno (fp, ECTF_NOTINTFP));
 981
 982   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE, &dtd)) == CTF_ERR)
 983     return CTF_ERR;             /* errno is set for us.  */
 984
 985   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
 986   dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
 987                                  / CHAR_BIT);
 988   dtd->dtd_u.dtu_slice.cts_type = (uint32_t) ref;
 989   dtd->dtd_u.dtu_slice.cts_bits = ep->cte_bits;
 990   dtd->dtd_u.dtu_slice.cts_offset = ep->cte_offset;
 991
 992   return type;
 993 }
 994
 995 ctf_id_t
 996 ctf_add_integer (ctf_file_t *fp, uint32_t flag,
 997                  const char *name, const ctf_encoding_t *ep)
 998 {
 999   return (ctf_add_encoded (fp, flag, name, ep, CTF_K_INTEGER));
1000 }
1001
1002 ctf_id_t
1003 ctf_add_float (ctf_file_t *fp, uint32_t flag,
1004                const char *name, const ctf_encoding_t *ep)
1005 {
1006   return (ctf_add_encoded (fp, flag, name, ep, CTF_K_FLOAT));
1007 }
1008
1009 ctf_id_t
1010 ctf_add_pointer (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1011 {
1012   return (ctf_add_reftype (fp, flag, ref, CTF_K_POINTER));
1013 }
1014
1015 ctf_id_t
1016 ctf_add_array (ctf_file_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
1017 {
1018   ctf_dtdef_t *dtd;
1019   ctf_id_t type;
1020   ctf_file_t *tmp = fp;
1021
1022   if (arp == NULL)
1023     return (ctf_set_errno (fp, EINVAL));
1024
1025   if (arp->ctr_contents != 0
1026       && ctf_lookup_by_id (&tmp, arp->ctr_contents) == NULL)
1027     return CTF_ERR;             /* errno is set for us.  */
1028
1029   tmp = fp;
1030   if (ctf_lookup_by_id (&tmp, arp->ctr_index) == NULL)
1031     return CTF_ERR;             /* errno is set for us.  */
1032
1033   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY, &dtd)) == CTF_ERR)
1034     return CTF_ERR;             /* errno is set for us.  */
1035
1036   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
1037   dtd->dtd_data.ctt_size = 0;
1038   dtd->dtd_u.dtu_arr = *arp;
1039
1040   return type;
1041 }
1042
1043 int
1044 ctf_set_array (ctf_file_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
1045 {
1046   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
1047
1048   if (!(fp->ctf_flags & LCTF_RDWR))
1049     return (ctf_set_errno (fp, ECTF_RDONLY));
1050
1051   if (dtd == NULL
1052       || LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
1053     return (ctf_set_errno (fp, ECTF_BADID));
1054
1055   fp->ctf_flags |= LCTF_DIRTY;
1056   dtd->dtd_u.dtu_arr = *arp;
1057
1058   return 0;
1059 }
1060
1061 ctf_id_t
1062 ctf_add_function (ctf_file_t *fp, uint32_t flag,
1063                   const ctf_funcinfo_t *ctc, const ctf_id_t *argv)
1064 {
1065   ctf_dtdef_t *dtd;
1066   ctf_id_t type;
1067   uint32_t vlen;
1068   uint32_t *vdat = NULL;
1069   ctf_file_t *tmp = fp;
1070   size_t i;
1071
1072   if (ctc == NULL || (ctc->ctc_flags & ~CTF_FUNC_VARARG) != 0
1073       || (ctc->ctc_argc != 0 && argv == NULL))
1074     return (ctf_set_errno (fp, EINVAL));
1075
1076   vlen = ctc->ctc_argc;
1077   if (ctc->ctc_flags & CTF_FUNC_VARARG)
1078     vlen++;            /* Add trailing zero to indicate varargs (see below).  */
1079
1080   if (ctc->ctc_return != 0
1081       && ctf_lookup_by_id (&tmp, ctc->ctc_return) == NULL)
1082     return CTF_ERR;             /* errno is set for us.  */
1083
1084   if (vlen > CTF_MAX_VLEN)
1085     return (ctf_set_errno (fp, EOVERFLOW));
1086
1087   if (vlen != 0 && (vdat = malloc (sizeof (ctf_id_t) * vlen)) == NULL)
1088     return (ctf_set_errno (fp, EAGAIN));
1089
1090   for (i = 0; i < ctc->ctc_argc; i++)
1091     {
1092       tmp = fp;
1093       if (argv[i] != 0 && ctf_lookup_by_id (&tmp, argv[i]) == NULL)
1094         {
1095           free (vdat);
1096           return CTF_ERR;          /* errno is set for us.  */
1097         }
1098       vdat[i] = (uint32_t) argv[i];
1099     }
1100
1101   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
1102                                &dtd)) == CTF_ERR)
1103     {
1104       free (vdat);
1105       return CTF_ERR;              /* errno is set for us.  */
1106     }
1107
1108   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
1109   dtd->dtd_data.ctt_type = (uint32_t) ctc->ctc_return;
1110
1111   if (ctc->ctc_flags & CTF_FUNC_VARARG)
1112     vdat[vlen - 1] = 0;            /* Add trailing zero to indicate varargs.  */
1113   dtd->dtd_u.dtu_argv = vdat;
1114
1115   return type;
1116 }
1117
1118 ctf_id_t
1119 ctf_add_struct_sized (ctf_file_t *fp, uint32_t flag, const char *name,
1120                       size_t size)
1121 {
1122   ctf_dtdef_t *dtd;
1123   ctf_id_t type = 0;
1124
1125   /* Promote root-visible forwards to structs.  */
1126   if (name != NULL)
1127     type = ctf_lookup_by_rawname (fp, CTF_K_STRUCT, name);
1128
1129   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1130     dtd = ctf_dtd_lookup (fp, type);
1131   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_STRUCT,
1132                                     &dtd)) == CTF_ERR)
1133     return CTF_ERR;             /* errno is set for us.  */
1134
1135   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
1136
1137   if (size > CTF_MAX_SIZE)
1138     {
1139       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1140       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1141       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1142     }
1143   else
1144     dtd->dtd_data.ctt_size = (uint32_t) size;
1145
1146   return type;
1147 }
1148
1149 ctf_id_t
1150 ctf_add_struct (ctf_file_t *fp, uint32_t flag, const char *name)
1151 {
1152   return (ctf_add_struct_sized (fp, flag, name, 0));
1153 }
1154
1155 ctf_id_t
1156 ctf_add_union_sized (ctf_file_t *fp, uint32_t flag, const char *name,
1157                      size_t size)
1158 {
1159   ctf_dtdef_t *dtd;
1160   ctf_id_t type = 0;
1161
1162   /* Promote root-visible forwards to unions.  */
1163   if (name != NULL)
1164     type = ctf_lookup_by_rawname (fp, CTF_K_UNION, name);
1165
1166   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1167     dtd = ctf_dtd_lookup (fp, type);
1168   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_UNION,
1169                                     &dtd)) == CTF_ERR)
1170     return CTF_ERR;             /* errno is set for us */
1171
1172   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
1173
1174   if (size > CTF_MAX_SIZE)
1175     {
1176       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1177       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1178       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1179     }
1180   else
1181     dtd->dtd_data.ctt_size = (uint32_t) size;
1182
1183   return type;
1184 }
1185
1186 ctf_id_t
1187 ctf_add_union (ctf_file_t *fp, uint32_t flag, const char *name)
1188 {
1189   return (ctf_add_union_sized (fp, flag, name, 0));
1190 }
1191
1192 ctf_id_t
1193 ctf_add_enum (ctf_file_t *fp, uint32_t flag, const char *name)
1194 {
1195   ctf_dtdef_t *dtd;
1196   ctf_id_t type = 0;
1197
1198   /* Promote root-visible forwards to enums.  */
1199   if (name != NULL)
1200     type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
1201
1202   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1203     dtd = ctf_dtd_lookup (fp, type);
1204   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_ENUM,
1205                                     &dtd)) == CTF_ERR)
1206     return CTF_ERR;             /* errno is set for us.  */
1207
1208   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
1209   dtd->dtd_data.ctt_size = fp->ctf_dmodel->ctd_int;
1210
1211   return type;
1212 }
1213
1214 ctf_id_t
1215 ctf_add_enum_encoded (ctf_file_t *fp, uint32_t flag, const char *name,
1216                       const ctf_encoding_t *ep)
1217 {
1218   ctf_id_t type = 0;
1219
1220   /* First, create the enum if need be, using most of the same machinery as
1221      ctf_add_enum(), to ensure that we do not allow things past that are not
1222      enums or forwards to them.  (This includes other slices: you cannot slice a
1223      slice, which would be a useless thing to do anyway.)  */
1224
1225   if (name != NULL)
1226     type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
1227
1228   if (type != 0)
1229     {
1230       if ((ctf_type_kind (fp, type) != CTF_K_FORWARD) &&
1231           (ctf_type_kind_unsliced (fp, type) != CTF_K_ENUM))
1232         return (ctf_set_errno (fp, ECTF_NOTINTFP));
1233     }
1234   else if ((type = ctf_add_enum (fp, flag, name)) == CTF_ERR)
1235     return CTF_ERR;             /* errno is set for us.  */
1236
1237   /* Now attach a suitable slice to it.  */
1238
1239   return ctf_add_slice (fp, flag, type, ep);
1240 }
1241
1242 ctf_id_t
1243 ctf_add_forward (ctf_file_t *fp, uint32_t flag, const char *name,
1244                  uint32_t kind)
1245 {
1246   ctf_dtdef_t *dtd;
1247   ctf_id_t type = 0;
1248
1249   if (!ctf_forwardable_kind (kind))
1250     return (ctf_set_errno (fp, ECTF_NOTSUE));
1251
1252   /* If the type is already defined or exists as a forward tag, just
1253      return the ctf_id_t of the existing definition.  */
1254
1255   if (name != NULL)
1256     type = ctf_lookup_by_rawname (fp, kind, name);
1257
1258   if (type)
1259     return type;
1260
1261   if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
1262     return CTF_ERR;             /* errno is set for us.  */
1263
1264   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
1265   dtd->dtd_data.ctt_type = kind;
1266
1267   return type;
1268 }
1269
1270 ctf_id_t
1271 ctf_add_typedef (ctf_file_t *fp, uint32_t flag, const char *name,
1272                  ctf_id_t ref)
1273 {
1274   ctf_dtdef_t *dtd;
1275   ctf_id_t type;
1276   ctf_file_t *tmp = fp;
1277
1278   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
1279     return (ctf_set_errno (fp, EINVAL));
1280
1281   if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
1282     return CTF_ERR;             /* errno is set for us.  */
1283
1284   if ((type = ctf_add_generic (fp, flag, name, CTF_K_TYPEDEF,
1285                                &dtd)) == CTF_ERR)
1286     return CTF_ERR;             /* errno is set for us.  */
1287
1288   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
1289   dtd->dtd_data.ctt_type = (uint32_t) ref;
1290
1291   return type;
1292 }
1293
1294 ctf_id_t
1295 ctf_add_volatile (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1296 {
1297   return (ctf_add_reftype (fp, flag, ref, CTF_K_VOLATILE));
1298 }
1299
1300 ctf_id_t
1301 ctf_add_const (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1302 {
1303   return (ctf_add_reftype (fp, flag, ref, CTF_K_CONST));
1304 }
1305
1306 ctf_id_t
1307 ctf_add_restrict (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1308 {
1309   return (ctf_add_reftype (fp, flag, ref, CTF_K_RESTRICT));
1310 }
1311
1312 int
1313 ctf_add_enumerator (ctf_file_t *fp, ctf_id_t enid, const char *name,
1314                     int value)
1315 {
1316   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, enid);
1317   ctf_dmdef_t *dmd;
1318
1319   uint32_t kind, vlen, root;
1320   char *s;
1321
1322   if (name == NULL)
1323     return (ctf_set_errno (fp, EINVAL));
1324
1325   if (!(fp->ctf_flags & LCTF_RDWR))
1326     return (ctf_set_errno (fp, ECTF_RDONLY));
1327
1328   if (dtd == NULL)
1329     return (ctf_set_errno (fp, ECTF_BADID));
1330
1331   kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1332   root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1333   vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1334
1335   if (kind != CTF_K_ENUM)
1336     return (ctf_set_errno (fp, ECTF_NOTENUM));
1337
1338   if (vlen == CTF_MAX_VLEN)
1339     return (ctf_set_errno (fp, ECTF_DTFULL));
1340
1341   for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1342        dmd != NULL; dmd = ctf_list_next (dmd))
1343     {
1344       if (strcmp (dmd->dmd_name, name) == 0)
1345         return (ctf_set_errno (fp, ECTF_DUPLICATE));
1346     }
1347
1348   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1349     return (ctf_set_errno (fp, EAGAIN));
1350
1351   if ((s = strdup (name)) == NULL)
1352     {
1353       free (dmd);
1354       return (ctf_set_errno (fp, EAGAIN));
1355     }
1356
1357   dmd->dmd_name = s;
1358   dmd->dmd_type = CTF_ERR;
1359   dmd->dmd_offset = 0;
1360   dmd->dmd_value = value;
1361
1362   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1363   ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1364
1365   fp->ctf_flags |= LCTF_DIRTY;
1366
1367   return 0;
1368 }
1369
1370 int
1371 ctf_add_member_offset (ctf_file_t *fp, ctf_id_t souid, const char *name,
1372                        ctf_id_t type, unsigned long bit_offset)
1373 {
1374   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, souid);
1375   ctf_dmdef_t *dmd;
1376
1377   ssize_t msize, malign, ssize;
1378   uint32_t kind, vlen, root;
1379   char *s = NULL;
1380
1381   if (!(fp->ctf_flags & LCTF_RDWR))
1382     return (ctf_set_errno (fp, ECTF_RDONLY));
1383
1384   if (dtd == NULL)
1385     return (ctf_set_errno (fp, ECTF_BADID));
1386
1387   if (name != NULL && name[0] == '\0')
1388     name = NULL;
1389
1390   kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1391   root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1392   vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1393
1394   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
1395     return (ctf_set_errno (fp, ECTF_NOTSOU));
1396
1397   if (vlen == CTF_MAX_VLEN)
1398     return (ctf_set_errno (fp, ECTF_DTFULL));
1399
1400   if (name != NULL)
1401     {
1402       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1403            dmd != NULL; dmd = ctf_list_next (dmd))
1404         {
1405           if (dmd->dmd_name != NULL && strcmp (dmd->dmd_name, name) == 0)
1406             return (ctf_set_errno (fp, ECTF_DUPLICATE));
1407         }
1408     }
1409
1410   if ((msize = ctf_type_size (fp, type)) < 0 ||
1411       (malign = ctf_type_align (fp, type)) < 0)
1412     {
1413       /* The unimplemented type, and any type that resolves to it, has no size
1414          and no alignment: it can correspond to any number of compiler-inserted
1415          types.  */
1416
1417       if (ctf_errno (fp) == ECTF_NONREPRESENTABLE)
1418         {
1419           msize = 0;
1420           malign = 0;
1421           ctf_set_errno (fp, 0);
1422         }
1423       else
1424         return -1;              /* errno is set for us.  */
1425     }
1426
1427   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1428     return (ctf_set_errno (fp, EAGAIN));
1429
1430   if (name != NULL && (s = strdup (name)) == NULL)
1431     {
1432       free (dmd);
1433       return (ctf_set_errno (fp, EAGAIN));
1434     }
1435
1436   dmd->dmd_name = s;
1437   dmd->dmd_type = type;
1438   dmd->dmd_value = -1;
1439
1440   if (kind == CTF_K_STRUCT && vlen != 0)
1441     {
1442       if (bit_offset == (unsigned long) - 1)
1443         {
1444           /* Natural alignment.  */
1445
1446           ctf_dmdef_t *lmd = ctf_list_prev (&dtd->dtd_u.dtu_members);
1447           ctf_id_t ltype = ctf_type_resolve (fp, lmd->dmd_type);
1448           size_t off = lmd->dmd_offset;
1449
1450           ctf_encoding_t linfo;
1451           ssize_t lsize;
1452
1453           /* Propagate any error from ctf_type_resolve.  If the last member was
1454              of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1455              cannot insert right after such a member without explicit offset
1456              specification, because its alignment and size is not known.  */
1457           if (ltype == CTF_ERR)
1458             {
1459               free (dmd);
1460               return -1;        /* errno is set for us.  */
1461             }
1462
1463           if (ctf_type_encoding (fp, ltype, &linfo) == 0)
1464             off += linfo.cte_bits;
1465           else if ((lsize = ctf_type_size (fp, ltype)) > 0)
1466             off += lsize * CHAR_BIT;
1467
1468           /* Round up the offset of the end of the last member to
1469              the next byte boundary, convert 'off' to bytes, and
1470              then round it up again to the next multiple of the
1471              alignment required by the new member.  Finally,
1472              convert back to bits and store the result in
1473              dmd_offset.  Technically we could do more efficient
1474              packing if the new member is a bit-field, but we're
1475              the "compiler" and ANSI says we can do as we choose.  */
1476
1477           off = roundup (off, CHAR_BIT) / CHAR_BIT;
1478           off = roundup (off, MAX (malign, 1));
1479           dmd->dmd_offset = off * CHAR_BIT;
1480           ssize = off + msize;
1481         }
1482       else
1483         {
1484           /* Specified offset in bits.  */
1485
1486           dmd->dmd_offset = bit_offset;
1487           ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1488           ssize = MAX (ssize, ((signed) bit_offset / CHAR_BIT) + msize);
1489         }
1490     }
1491   else
1492     {
1493       dmd->dmd_offset = 0;
1494       ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1495       ssize = MAX (ssize, msize);
1496     }
1497
1498   if ((size_t) ssize > CTF_MAX_SIZE)
1499     {
1500       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1501       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (ssize);
1502       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (ssize);
1503     }
1504   else
1505     dtd->dtd_data.ctt_size = (uint32_t) ssize;
1506
1507   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1508   ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1509
1510   fp->ctf_flags |= LCTF_DIRTY;
1511   return 0;
1512 }
1513
1514 int
1515 ctf_add_member_encoded (ctf_file_t *fp, ctf_id_t souid, const char *name,
1516                         ctf_id_t type, unsigned long bit_offset,
1517                         const ctf_encoding_t encoding)
1518 {
1519   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
1520   int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1521   int otype = type;
1522
1523   if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) && (kind != CTF_K_ENUM))
1524     return (ctf_set_errno (fp, ECTF_NOTINTFP));
1525
1526   if ((type = ctf_add_slice (fp, CTF_ADD_NONROOT, otype, &encoding)) == CTF_ERR)
1527     return -1;                  /* errno is set for us.  */
1528
1529   return ctf_add_member_offset (fp, souid, name, type, bit_offset);
1530 }
1531
1532 int
1533 ctf_add_member (ctf_file_t *fp, ctf_id_t souid, const char *name,
1534                 ctf_id_t type)
1535 {
1536   return ctf_add_member_offset (fp, souid, name, type, (unsigned long) - 1);
1537 }
1538
1539 int
1540 ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
1541 {
1542   ctf_dvdef_t *dvd;
1543   ctf_file_t *tmp = fp;
1544
1545   if (!(fp->ctf_flags & LCTF_RDWR))
1546     return (ctf_set_errno (fp, ECTF_RDONLY));
1547
1548   if (ctf_dvd_lookup (fp, name) != NULL)
1549     return (ctf_set_errno (fp, ECTF_DUPLICATE));
1550
1551   if (ctf_lookup_by_id (&tmp, ref) == NULL)
1552     return -1;                  /* errno is set for us.  */
1553
1554   /* Make sure this type is representable.  */
1555   if ((ctf_type_resolve (fp, ref) == CTF_ERR)
1556       && (ctf_errno (fp) == ECTF_NONREPRESENTABLE))
1557     return -1;
1558
1559   if ((dvd = malloc (sizeof (ctf_dvdef_t))) == NULL)
1560     return (ctf_set_errno (fp, EAGAIN));
1561
1562   if (name != NULL && (dvd->dvd_name = strdup (name)) == NULL)
1563     {
1564       free (dvd);
1565       return (ctf_set_errno (fp, EAGAIN));
1566     }
1567   dvd->dvd_type = ref;
1568   dvd->dvd_snapshots = fp->ctf_snapshots;
1569
1570   if (ctf_dvd_insert (fp, dvd) < 0)
1571     {
1572       free (dvd->dvd_name);
1573       free (dvd);
1574       return -1;                        /* errno is set for us.  */
1575     }
1576
1577   fp->ctf_flags |= LCTF_DIRTY;
1578   return 0;
1579 }
1580
1581 static int
1582 enumcmp (const char *name, int value, void *arg)
1583 {
1584   ctf_bundle_t *ctb = arg;
1585   int bvalue;
1586
1587   if (ctf_enum_value (ctb->ctb_file, ctb->ctb_type, name, &bvalue) < 0)
1588     {
1589       ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name,
1590                    ctf_errmsg (ctf_errno (ctb->ctb_file)));
1591       return 1;
1592     }
1593   if (value != bvalue)
1594     {
1595       ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1596                    value, bvalue);
1597       return 1;
1598     }
1599   return 0;
1600 }
1601
1602 static int
1603 enumadd (const char *name, int value, void *arg)
1604 {
1605   ctf_bundle_t *ctb = arg;
1606
1607   return (ctf_add_enumerator (ctb->ctb_file, ctb->ctb_type,
1608                               name, value) < 0);
1609 }
1610
1611 static int
1612 membcmp (const char *name, ctf_id_t type _libctf_unused_, unsigned long offset,
1613          void *arg)
1614 {
1615   ctf_bundle_t *ctb = arg;
1616   ctf_membinfo_t ctm;
1617
1618   /* Don't check nameless members (e.g. anonymous structs/unions) against each
1619      other.  */
1620   if (name[0] == 0)
1621     return 0;
1622
1623   if (ctf_member_info (ctb->ctb_file, ctb->ctb_type, name, &ctm) < 0)
1624     {
1625       ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name,
1626                    ctf_errmsg (ctf_errno (ctb->ctb_file)));
1627       return 1;
1628     }
1629   if (ctm.ctm_offset != offset)
1630     {
1631       ctf_dprintf ("Conflict due to member %s offset change: "
1632                    "%lx versus %lx\n", name, ctm.ctm_offset, offset);
1633       return 1;
1634     }
1635   return 0;
1636 }
1637
1638 static int
1639 membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
1640 {
1641   ctf_bundle_t *ctb = arg;
1642   ctf_dmdef_t *dmd;
1643   char *s = NULL;
1644
1645   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1646     return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1647
1648   if (name != NULL && (s = strdup (name)) == NULL)
1649     {
1650       free (dmd);
1651       return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1652     }
1653
1654   /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1655     equivalent dst_fp type by a final loop in ctf_add_type(), below.  */
1656   dmd->dmd_name = s;
1657   dmd->dmd_type = type;
1658   dmd->dmd_offset = offset;
1659   dmd->dmd_value = -1;
1660
1661   ctf_list_append (&ctb->ctb_dtd->dtd_u.dtu_members, dmd);
1662
1663   ctb->ctb_file->ctf_flags |= LCTF_DIRTY;
1664   return 0;
1665 }
1666
1667 /* The ctf_add_type routine is used to copy a type from a source CTF container
1668    to a dynamic destination container.  This routine operates recursively by
1669    following the source type's links and embedded member types.  If the
1670    destination container already contains a named type which has the same
1671    attributes, then we succeed and return this type but no changes occur.  */
1672 static ctf_id_t
1673 ctf_add_type_internal (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type,
1674                        ctf_file_t *proc_tracking_fp)
1675 {
1676   ctf_id_t dst_type = CTF_ERR;
1677   uint32_t dst_kind = CTF_K_UNKNOWN;
1678   ctf_file_t *tmp_fp = dst_fp;
1679   ctf_id_t tmp;
1680
1681   const char *name;
1682   uint32_t kind, forward_kind, flag, vlen;
1683
1684   const ctf_type_t *src_tp, *dst_tp;
1685   ctf_bundle_t src, dst;
1686   ctf_encoding_t src_en, dst_en;
1687   ctf_arinfo_t src_ar, dst_ar;
1688
1689   ctf_funcinfo_t ctc;
1690
1691   ctf_id_t orig_src_type = src_type;
1692
1693   if (!(dst_fp->ctf_flags & LCTF_RDWR))
1694     return (ctf_set_errno (dst_fp, ECTF_RDONLY));
1695
1696   if ((src_tp = ctf_lookup_by_id (&src_fp, src_type)) == NULL)
1697     return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1698
1699   if ((ctf_type_resolve (src_fp, src_type) == CTF_ERR)
1700       && (ctf_errno (src_fp) == ECTF_NONREPRESENTABLE))
1701     return (ctf_set_errno (dst_fp, ECTF_NONREPRESENTABLE));
1702
1703   name = ctf_strptr (src_fp, src_tp->ctt_name);
1704   kind = LCTF_INFO_KIND (src_fp, src_tp->ctt_info);
1705   flag = LCTF_INFO_ISROOT (src_fp, src_tp->ctt_info);
1706   vlen = LCTF_INFO_VLEN (src_fp, src_tp->ctt_info);
1707
1708   /* If this is a type we are currently in the middle of adding, hand it
1709      straight back.  (This lets us handle self-referential structures without
1710      considering forwards and empty structures the same as their completed
1711      forms.)  */
1712
1713   tmp = ctf_type_mapping (src_fp, src_type, &tmp_fp);
1714
1715   if (tmp != 0)
1716     {
1717       if (ctf_dynhash_lookup (proc_tracking_fp->ctf_add_processing,
1718                               (void *) (uintptr_t) src_type))
1719         return tmp;
1720
1721       /* If this type has already been added from this container, and is the same
1722          kind and (if a struct or union) has the same number of members, hand it
1723          straight back.  */
1724
1725       if (ctf_type_kind_unsliced (tmp_fp, tmp) == (int) kind)
1726         {
1727           if (kind == CTF_K_STRUCT || kind == CTF_K_UNION
1728               || kind == CTF_K_ENUM)
1729             {
1730               if ((dst_tp = ctf_lookup_by_id (&tmp_fp, dst_type)) != NULL)
1731                 if (vlen == LCTF_INFO_VLEN (tmp_fp, dst_tp->ctt_info))
1732                   return tmp;
1733             }
1734           else
1735             return tmp;
1736         }
1737     }
1738
1739   forward_kind = kind;
1740   if (kind == CTF_K_FORWARD)
1741     forward_kind = src_tp->ctt_type;
1742
1743   /* If the source type has a name and is a root type (visible at the
1744      top-level scope), lookup the name in the destination container and
1745      verify that it is of the same kind before we do anything else.  */
1746
1747   if ((flag & CTF_ADD_ROOT) && name[0] != '\0'
1748       && (tmp = ctf_lookup_by_rawname (dst_fp, forward_kind, name)) != 0)
1749     {
1750       dst_type = tmp;
1751       dst_kind = ctf_type_kind_unsliced (dst_fp, dst_type);
1752     }
1753
1754   /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1755      unless dst_type is a forward declaration and src_type is a struct,
1756      union, or enum (i.e. the definition of the previous forward decl).
1757
1758      We also allow addition in the opposite order (addition of a forward when a
1759      struct, union, or enum already exists), which is a NOP and returns the
1760      already-present struct, union, or enum.  */
1761
1762   if (dst_type != CTF_ERR && dst_kind != kind)
1763     {
1764       if (kind == CTF_K_FORWARD
1765           && (dst_kind == CTF_K_ENUM || dst_kind == CTF_K_STRUCT
1766               || dst_kind == CTF_K_UNION))
1767         {
1768           ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1769           return dst_type;
1770         }
1771
1772       if (dst_kind != CTF_K_FORWARD
1773           || (kind != CTF_K_ENUM && kind != CTF_K_STRUCT
1774               && kind != CTF_K_UNION))
1775         {
1776           ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1777                        "old (ID %lx): %i\n", name, kind, dst_type, dst_kind);
1778           return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1779         }
1780     }
1781
1782   /* We take special action for an integer, float, or slice since it is
1783      described not only by its name but also its encoding.  For integers,
1784      bit-fields exploit this degeneracy.  */
1785
1786   if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT || kind == CTF_K_SLICE)
1787     {
1788       if (ctf_type_encoding (src_fp, src_type, &src_en) != 0)
1789         return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1790
1791       if (dst_type != CTF_ERR)
1792         {
1793           ctf_file_t *fp = dst_fp;
1794
1795           if ((dst_tp = ctf_lookup_by_id (&fp, dst_type)) == NULL)
1796             return CTF_ERR;
1797
1798           if (ctf_type_encoding (dst_fp, dst_type, &dst_en) != 0)
1799             return CTF_ERR;                     /* errno set for us.  */
1800
1801           if (LCTF_INFO_ISROOT (fp, dst_tp->ctt_info) & CTF_ADD_ROOT)
1802             {
1803               /* The type that we found in the hash is also root-visible.  If
1804                  the two types match then use the existing one; otherwise,
1805                  declare a conflict.  Note: slices are not certain to match
1806                  even if there is no conflict: we must check the contained type
1807                  too.  */
1808
1809               if (memcmp (&src_en, &dst_en, sizeof (ctf_encoding_t)) == 0)
1810                 {
1811                   if (kind != CTF_K_SLICE)
1812                     {
1813                       ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1814                       return dst_type;
1815                     }
1816                 }
1817               else
1818                   {
1819                     return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1820                   }
1821             }
1822           else
1823             {
1824               /* We found a non-root-visible type in the hash.  If its encoding
1825                  is the same, we can reuse it, unless it is a slice.  */
1826
1827               if (memcmp (&src_en, &dst_en, sizeof (ctf_encoding_t)) == 0)
1828                 {
1829                   if (kind != CTF_K_SLICE)
1830                     {
1831                       ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1832                       return dst_type;
1833                     }
1834                 }
1835             }
1836         }
1837     }
1838
1839   src.ctb_file = src_fp;
1840   src.ctb_type = src_type;
1841   src.ctb_dtd = NULL;
1842
1843   dst.ctb_file = dst_fp;
1844   dst.ctb_type = dst_type;
1845   dst.ctb_dtd = NULL;
1846
1847   /* Now perform kind-specific processing.  If dst_type is CTF_ERR, then we add
1848      a new type with the same properties as src_type to dst_fp.  If dst_type is
1849      not CTF_ERR, then we verify that dst_type has the same attributes as
1850      src_type.  We recurse for embedded references.  Before we start, we note
1851      that we are processing this type, to prevent infinite recursion: we do not
1852      re-process any type that appears in this list.  The list is emptied
1853      wholesale at the end of processing everything in this recursive stack.  */
1854
1855   if (ctf_dynhash_insert (proc_tracking_fp->ctf_add_processing,
1856                           (void *) (uintptr_t) src_type, (void *) 1) < 0)
1857     return ctf_set_errno (dst_fp, ENOMEM);
1858
1859   switch (kind)
1860     {
1861     case CTF_K_INTEGER:
1862       /*  If we found a match we will have either returned it or declared a
1863           conflict.  */
1864       dst_type = ctf_add_integer (dst_fp, flag, name, &src_en);
1865       break;
1866
1867     case CTF_K_FLOAT:
1868       /* If we found a match we will have either returned it or declared a
1869        conflict.  */
1870       dst_type = ctf_add_float (dst_fp, flag, name, &src_en);
1871       break;
1872
1873     case CTF_K_SLICE:
1874       /* We have checked for conflicting encodings: now try to add the
1875          contained type.  */
1876       src_type = ctf_type_reference (src_fp, src_type);
1877       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
1878                                         proc_tracking_fp);
1879
1880       if (src_type == CTF_ERR)
1881         return CTF_ERR;                         /* errno is set for us.  */
1882
1883       dst_type = ctf_add_slice (dst_fp, flag, src_type, &src_en);
1884       break;
1885
1886     case CTF_K_POINTER:
1887     case CTF_K_VOLATILE:
1888     case CTF_K_CONST:
1889     case CTF_K_RESTRICT:
1890       src_type = ctf_type_reference (src_fp, src_type);
1891       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
1892                                         proc_tracking_fp);
1893
1894       if (src_type == CTF_ERR)
1895         return CTF_ERR;                         /* errno is set for us.  */
1896
1897       dst_type = ctf_add_reftype (dst_fp, flag, src_type, kind);
1898       break;
1899
1900     case CTF_K_ARRAY:
1901       if (ctf_array_info (src_fp, src_type, &src_ar) != 0)
1902         return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1903
1904       src_ar.ctr_contents =
1905         ctf_add_type_internal (dst_fp, src_fp, src_ar.ctr_contents,
1906                                proc_tracking_fp);
1907       src_ar.ctr_index = ctf_add_type_internal (dst_fp, src_fp,
1908                                                 src_ar.ctr_index,
1909                                                 proc_tracking_fp);
1910       src_ar.ctr_nelems = src_ar.ctr_nelems;
1911
1912       if (src_ar.ctr_contents == CTF_ERR || src_ar.ctr_index == CTF_ERR)
1913         return CTF_ERR;                         /* errno is set for us.  */
1914
1915       if (dst_type != CTF_ERR)
1916         {
1917           if (ctf_array_info (dst_fp, dst_type, &dst_ar) != 0)
1918             return CTF_ERR;                     /* errno is set for us.  */
1919
1920           if (memcmp (&src_ar, &dst_ar, sizeof (ctf_arinfo_t)))
1921             {
1922               ctf_dprintf ("Conflict for type %s against ID %lx: "
1923                            "array info differs, old %lx/%lx/%x; "
1924                            "new: %lx/%lx/%x\n", name, dst_type,
1925                            src_ar.ctr_contents, src_ar.ctr_index,
1926                            src_ar.ctr_nelems, dst_ar.ctr_contents,
1927                            dst_ar.ctr_index, dst_ar.ctr_nelems);
1928               return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1929             }
1930         }
1931       else
1932         dst_type = ctf_add_array (dst_fp, flag, &src_ar);
1933       break;
1934
1935     case CTF_K_FUNCTION:
1936       ctc.ctc_return = ctf_add_type_internal (dst_fp, src_fp,
1937                                               src_tp->ctt_type,
1938                                               proc_tracking_fp);
1939       ctc.ctc_argc = 0;
1940       ctc.ctc_flags = 0;
1941
1942       if (ctc.ctc_return == CTF_ERR)
1943         return CTF_ERR;                         /* errno is set for us.  */
1944
1945       dst_type = ctf_add_function (dst_fp, flag, &ctc, NULL);
1946       break;
1947
1948     case CTF_K_STRUCT:
1949     case CTF_K_UNION:
1950       {
1951         ctf_dmdef_t *dmd;
1952         int errs = 0;
1953         size_t size;
1954         ssize_t ssize;
1955         ctf_dtdef_t *dtd;
1956
1957         /* Technically to match a struct or union we need to check both
1958            ways (src members vs. dst, dst members vs. src) but we make
1959            this more optimal by only checking src vs. dst and comparing
1960            the total size of the structure (which we must do anyway)
1961            which covers the possibility of dst members not in src.
1962            This optimization can be defeated for unions, but is so
1963            pathological as to render it irrelevant for our purposes.  */
1964
1965         if (dst_type != CTF_ERR && kind != CTF_K_FORWARD
1966             && dst_kind != CTF_K_FORWARD)
1967           {
1968             if (ctf_type_size (src_fp, src_type) !=
1969                 ctf_type_size (dst_fp, dst_type))
1970               {
1971                 ctf_dprintf ("Conflict for type %s against ID %lx: "
1972                              "union size differs, old %li, new %li\n",
1973                              name, dst_type,
1974                              (long) ctf_type_size (src_fp, src_type),
1975                              (long) ctf_type_size (dst_fp, dst_type));
1976                 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1977               }
1978
1979             if (ctf_member_iter (src_fp, src_type, membcmp, &dst))
1980               {
1981                 ctf_dprintf ("Conflict for type %s against ID %lx: "
1982                              "members differ, see above\n", name, dst_type);
1983                 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1984               }
1985
1986             break;
1987           }
1988
1989         /* Unlike the other cases, copying structs and unions is done
1990            manually so as to avoid repeated lookups in ctf_add_member
1991            and to ensure the exact same member offsets as in src_type.  */
1992
1993         dst_type = ctf_add_generic (dst_fp, flag, name, kind, &dtd);
1994         if (dst_type == CTF_ERR)
1995           return CTF_ERR;                       /* errno is set for us.  */
1996
1997         dst.ctb_type = dst_type;
1998         dst.ctb_dtd = dtd;
1999
2000         /* Pre-emptively add this struct to the type mapping so that
2001            structures that refer to themselves work.  */
2002         ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
2003
2004         if (ctf_member_iter (src_fp, src_type, membadd, &dst) != 0)
2005           errs++;              /* Increment errs and fail at bottom of case.  */
2006
2007         if ((ssize = ctf_type_size (src_fp, src_type)) < 0)
2008           return CTF_ERR;                       /* errno is set for us.  */
2009
2010         size = (size_t) ssize;
2011         if (size > CTF_MAX_SIZE)
2012           {
2013             dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
2014             dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
2015             dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
2016           }
2017         else
2018           dtd->dtd_data.ctt_size = (uint32_t) size;
2019
2020         dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, vlen);
2021
2022         /* Make a final pass through the members changing each dmd_type (a
2023            src_fp type) to an equivalent type in dst_fp.  We pass through all
2024            members, leaving any that fail set to CTF_ERR, unless they fail
2025            because they are marking a member of type not representable in this
2026            version of CTF, in which case we just want to silently omit them:
2027            no consumer can do anything with them anyway.  */
2028         for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
2029              dmd != NULL; dmd = ctf_list_next (dmd))
2030           {
2031             ctf_file_t *dst = dst_fp;
2032             ctf_id_t memb_type;
2033
2034             memb_type = ctf_type_mapping (src_fp, dmd->dmd_type, &dst);
2035             if (memb_type == 0)
2036               {
2037                 if ((dmd->dmd_type =
2038                      ctf_add_type_internal (dst_fp, src_fp, dmd->dmd_type,
2039                                             proc_tracking_fp)) == CTF_ERR)
2040                   {
2041                     if (ctf_errno (dst_fp) != ECTF_NONREPRESENTABLE)
2042                       errs++;
2043                   }
2044               }
2045             else
2046               dmd->dmd_type = memb_type;
2047           }
2048
2049         if (errs)
2050           return CTF_ERR;                       /* errno is set for us.  */
2051         break;
2052       }
2053
2054     case CTF_K_ENUM:
2055       if (dst_type != CTF_ERR && kind != CTF_K_FORWARD
2056           && dst_kind != CTF_K_FORWARD)
2057         {
2058           if (ctf_enum_iter (src_fp, src_type, enumcmp, &dst)
2059               || ctf_enum_iter (dst_fp, dst_type, enumcmp, &src))
2060             {
2061               ctf_dprintf ("Conflict for enum %s against ID %lx: "
2062                            "members differ, see above\n", name, dst_type);
2063               return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
2064             }
2065         }
2066       else
2067         {
2068           dst_type = ctf_add_enum (dst_fp, flag, name);
2069           if ((dst.ctb_type = dst_type) == CTF_ERR
2070               || ctf_enum_iter (src_fp, src_type, enumadd, &dst))
2071             return CTF_ERR;                     /* errno is set for us */
2072         }
2073       break;
2074
2075     case CTF_K_FORWARD:
2076       if (dst_type == CTF_ERR)
2077           dst_type = ctf_add_forward (dst_fp, flag, name, forward_kind);
2078       break;
2079
2080     case CTF_K_TYPEDEF:
2081       src_type = ctf_type_reference (src_fp, src_type);
2082       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
2083                                         proc_tracking_fp);
2084
2085       if (src_type == CTF_ERR)
2086         return CTF_ERR;                         /* errno is set for us.  */
2087
2088       /* If dst_type is not CTF_ERR at this point, we should check if
2089          ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2090          ECTF_CONFLICT.  However, this causes problems with bitness typedefs
2091          that vary based on things like if 32-bit then pid_t is int otherwise
2092          long.  We therefore omit this check and assume that if the identically
2093          named typedef already exists in dst_fp, it is correct or
2094          equivalent.  */
2095
2096       if (dst_type == CTF_ERR)
2097           dst_type = ctf_add_typedef (dst_fp, flag, name, src_type);
2098
2099       break;
2100
2101     default:
2102       return (ctf_set_errno (dst_fp, ECTF_CORRUPT));
2103     }
2104
2105   if (dst_type != CTF_ERR)
2106     ctf_add_type_mapping (src_fp, orig_src_type, dst_fp, dst_type);
2107   return dst_type;
2108 }
2109
2110 ctf_id_t
2111 ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
2112 {
2113   ctf_id_t id;
2114
2115   if (!src_fp->ctf_add_processing)
2116     src_fp->ctf_add_processing = ctf_dynhash_create (ctf_hash_integer,
2117                                                      ctf_hash_eq_integer,
2118                                                      NULL, NULL);
2119
2120   /* We store the hash on the source, because it contains only source type IDs:
2121      but callers will invariably expect errors to appear on the dest.  */
2122   if (!src_fp->ctf_add_processing)
2123     return (ctf_set_errno (dst_fp, ENOMEM));
2124
2125   id = ctf_add_type_internal (dst_fp, src_fp, src_type, src_fp);
2126   ctf_dynhash_empty (src_fp->ctf_add_processing);
2127
2128   return id;
2129 }
2130
2131 /* Write the compressed CTF data stream to the specified gzFile descriptor.  */
2132 int
2133 ctf_gzwrite (ctf_file_t *fp, gzFile fd)
2134 {
2135   const unsigned char *buf;
2136   ssize_t resid;
2137   ssize_t len;
2138
2139   resid = sizeof (ctf_header_t);
2140   buf = (unsigned char *) fp->ctf_header;
2141   while (resid != 0)
2142     {
2143       if ((len = gzwrite (fd, buf, resid)) <= 0)
2144         return (ctf_set_errno (fp, errno));
2145       resid -= len;
2146       buf += len;
2147     }
2148
2149   resid = fp->ctf_size;
2150   buf = fp->ctf_buf;
2151   while (resid != 0)
2152     {
2153       if ((len = gzwrite (fd, buf, resid)) <= 0)
2154         return (ctf_set_errno (fp, errno));
2155       resid -= len;
2156       buf += len;
2157     }
2158
2159   return 0;
2160 }
2161
2162 /* Compress the specified CTF data stream and write it to the specified file
2163    descriptor.  */
2164 int
2165 ctf_compress_write (ctf_file_t *fp, int fd)
2166 {
2167   unsigned char *buf;
2168   unsigned char *bp;
2169   ctf_header_t h;
2170   ctf_header_t *hp = &h;
2171   ssize_t header_len = sizeof (ctf_header_t);
2172   ssize_t compress_len;
2173   ssize_t len;
2174   int rc;
2175   int err = 0;
2176
2177   if (ctf_serialize (fp) < 0)
2178     return -1;                                  /* errno is set for us.  */
2179
2180   memcpy (hp, fp->ctf_header, header_len);
2181   hp->cth_flags |= CTF_F_COMPRESS;
2182   compress_len = compressBound (fp->ctf_size);
2183
2184   if ((buf = malloc (compress_len)) == NULL)
2185     return (ctf_set_errno (fp, ECTF_ZALLOC));
2186
2187   if ((rc = compress (buf, (uLongf *) &compress_len,
2188                       fp->ctf_buf, fp->ctf_size)) != Z_OK)
2189     {
2190       ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
2191       err = ctf_set_errno (fp, ECTF_COMPRESS);
2192       goto ret;
2193     }
2194
2195   while (header_len > 0)
2196     {
2197       if ((len = write (fd, hp, header_len)) < 0)
2198         {
2199           err = ctf_set_errno (fp, errno);
2200           goto ret;
2201         }
2202       header_len -= len;
2203       hp += len;
2204     }
2205
2206   bp = buf;
2207   while (compress_len > 0)
2208     {
2209       if ((len = write (fd, bp, compress_len)) < 0)
2210         {
2211           err = ctf_set_errno (fp, errno);
2212           goto ret;
2213         }
2214       compress_len -= len;
2215       bp += len;
2216     }
2217
2218 ret:
2219   free (buf);
2220   return err;
2221 }
2222
2223 /* Optionally compress the specified CTF data stream and return it as a new
2224    dynamically-allocated string.  */
2225 unsigned char *
2226 ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
2227 {
2228   unsigned char *buf;
2229   unsigned char *bp;
2230   ctf_header_t *hp;
2231   ssize_t header_len = sizeof (ctf_header_t);
2232   ssize_t compress_len;
2233   int rc;
2234
2235   if (ctf_serialize (fp) < 0)
2236     return NULL;                                /* errno is set for us.  */
2237
2238   compress_len = compressBound (fp->ctf_size);
2239   if (fp->ctf_size < threshold)
2240     compress_len = fp->ctf_size;
2241   if ((buf = malloc (compress_len
2242                      + sizeof (struct ctf_header))) == NULL)
2243     {
2244       ctf_set_errno (fp, ENOMEM);
2245       return NULL;
2246     }
2247
2248   hp = (ctf_header_t *) buf;
2249   memcpy (hp, fp->ctf_header, header_len);
2250   bp = buf + sizeof (struct ctf_header);
2251   *size = sizeof (struct ctf_header);
2252
2253   if (fp->ctf_size < threshold)
2254     {
2255       hp->cth_flags &= ~CTF_F_COMPRESS;
2256       memcpy (bp, fp->ctf_buf, fp->ctf_size);
2257       *size += fp->ctf_size;
2258     }
2259   else
2260     {
2261       hp->cth_flags |= CTF_F_COMPRESS;
2262       if ((rc = compress (bp, (uLongf *) &compress_len,
2263                           fp->ctf_buf, fp->ctf_size)) != Z_OK)
2264         {
2265           ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
2266           ctf_set_errno (fp, ECTF_COMPRESS);
2267           free (buf);
2268           return NULL;
2269         }
2270       *size += compress_len;
2271     }
2272   return buf;
2273 }
2274
2275 /* Write the uncompressed CTF data stream to the specified file descriptor.  */
2276 int
2277 ctf_write (ctf_file_t *fp, int fd)
2278 {
2279   const unsigned char *buf;
2280   ssize_t resid;
2281   ssize_t len;
2282
2283   if (ctf_serialize (fp) < 0)
2284     return -1;                                  /* errno is set for us.  */
2285
2286   resid = sizeof (ctf_header_t);
2287   buf = (unsigned char *) fp->ctf_header;
2288   while (resid != 0)
2289     {
2290       if ((len = write (fd, buf, resid)) <= 0)
2291         return (ctf_set_errno (fp, errno));
2292       resid -= len;
2293       buf += len;
2294     }
2295
2296   resid = fp->ctf_size;
2297   buf = fp->ctf_buf;
2298   while (resid != 0)
2299     {
2300       if ((len = write (fd, buf, resid)) <= 0)
2301         return (ctf_set_errno (fp, errno));
2302       resid -= len;
2303       buf += len;
2304     }
2305
2306   return 0;
2307 }