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_in_cu_mapping = fp->ctf_link_in_cu_mapping;
 542   nfp->ctf_link_out_cu_mapping = fp->ctf_link_out_cu_mapping;
 543   nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
 544   nfp->ctf_link_memb_name_changer = fp->ctf_link_memb_name_changer;
 545   nfp->ctf_link_memb_name_changer_arg = fp->ctf_link_memb_name_changer_arg;
 546   nfp->ctf_link_flags = fp->ctf_link_flags;
 547
 548   nfp->ctf_snapshot_lu = fp->ctf_snapshots;
 549
 550   memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
 551   nfp->ctf_structs = fp->ctf_structs;
 552   nfp->ctf_unions = fp->ctf_unions;
 553   nfp->ctf_enums = fp->ctf_enums;
 554   nfp->ctf_names = fp->ctf_names;
 555
 556   fp->ctf_dthash = NULL;
 557   ctf_str_free_atoms (nfp);
 558   nfp->ctf_str_atoms = fp->ctf_str_atoms;
 559   nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
 560   fp->ctf_str_atoms = NULL;
 561   fp->ctf_prov_strtab = NULL;
 562   memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
 563   memset (&fp->ctf_errs_warnings, 0, sizeof (ctf_list_t));
 564   fp->ctf_add_processing = NULL;
 565   fp->ctf_ptrtab = NULL;
 566   fp->ctf_link_inputs = NULL;
 567   fp->ctf_link_outputs = NULL;
 568   fp->ctf_syn_ext_strtab = NULL;
 569   fp->ctf_link_in_cu_mapping = NULL;
 570   fp->ctf_link_out_cu_mapping = NULL;
 571   fp->ctf_link_type_mapping = NULL;
 572   fp->ctf_parent_unreffed = 1;
 573
 574   fp->ctf_dvhash = NULL;
 575   memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
 576   memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
 577   fp->ctf_structs.ctn_writable = NULL;
 578   fp->ctf_unions.ctn_writable = NULL;
 579   fp->ctf_enums.ctn_writable = NULL;
 580   fp->ctf_names.ctn_writable = NULL;
 581
 582   memcpy (&ofp, fp, sizeof (ctf_file_t));
 583   memcpy (fp, nfp, sizeof (ctf_file_t));
 584   memcpy (nfp, &ofp, sizeof (ctf_file_t));
 585
 586   nfp->ctf_refcnt = 1;          /* Force nfp to be freed.  */
 587   ctf_file_close (nfp);
 588
 589   return 0;
 590 }
 591
 592 ctf_names_t *
 593 ctf_name_table (ctf_file_t *fp, int kind)
 594 {
 595   switch (kind)
 596     {
 597     case CTF_K_STRUCT:
 598       return &fp->ctf_structs;
 599     case CTF_K_UNION:
 600       return &fp->ctf_unions;
 601     case CTF_K_ENUM:
 602       return &fp->ctf_enums;
 603     default:
 604       return &fp->ctf_names;
 605     }
 606 }
 607
 608 int
 609 ctf_dtd_insert (ctf_file_t *fp, ctf_dtdef_t *dtd, int flag, int kind)
 610 {
 611   const char *name;
 612   if (ctf_dynhash_insert (fp->ctf_dthash, (void *) dtd->dtd_type, dtd) < 0)
 613     return -1;
 614
 615   if (flag == CTF_ADD_ROOT && dtd->dtd_data.ctt_name
 616       && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
 617     {
 618       if (ctf_dynhash_insert (ctf_name_table (fp, kind)->ctn_writable,
 619                               (char *) name, (void *) dtd->dtd_type) < 0)
 620         {
 621           ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 622           return -1;
 623         }
 624     }
 625   ctf_list_append (&fp->ctf_dtdefs, dtd);
 626   return 0;
 627 }
 628
 629 void
 630 ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
 631 {
 632   ctf_dmdef_t *dmd, *nmd;
 633   int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 634   int name_kind = kind;
 635   const char *name;
 636
 637   ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 638
 639   switch (kind)
 640     {
 641     case CTF_K_STRUCT:
 642     case CTF_K_UNION:
 643     case CTF_K_ENUM:
 644       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 645            dmd != NULL; dmd = nmd)
 646         {
 647           if (dmd->dmd_name != NULL)
 648               free (dmd->dmd_name);
 649           nmd = ctf_list_next (dmd);
 650           free (dmd);
 651         }
 652       break;
 653     case CTF_K_FUNCTION:
 654       free (dtd->dtd_u.dtu_argv);
 655       break;
 656     case CTF_K_FORWARD:
 657       name_kind = dtd->dtd_data.ctt_type;
 658       break;
 659     }
 660
 661   if (dtd->dtd_data.ctt_name
 662       && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL
 663       && LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info))
 664     {
 665       ctf_dynhash_remove (ctf_name_table (fp, name_kind)->ctn_writable,
 666                           name);
 667       ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
 668     }
 669
 670   ctf_list_delete (&fp->ctf_dtdefs, dtd);
 671   free (dtd);
 672 }
 673
 674 ctf_dtdef_t *
 675 ctf_dtd_lookup (const ctf_file_t *fp, ctf_id_t type)
 676 {
 677   return (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dthash, (void *) type);
 678 }
 679
 680 ctf_dtdef_t *
 681 ctf_dynamic_type (const ctf_file_t *fp, ctf_id_t id)
 682 {
 683   ctf_id_t idx;
 684
 685   if (!(fp->ctf_flags & LCTF_RDWR))
 686     return NULL;
 687
 688   if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, id))
 689     fp = fp->ctf_parent;
 690
 691   idx = LCTF_TYPE_TO_INDEX(fp, id);
 692
 693   if ((unsigned long) idx <= fp->ctf_typemax)
 694     return ctf_dtd_lookup (fp, id);
 695   return NULL;
 696 }
 697
 698 int
 699 ctf_dvd_insert (ctf_file_t *fp, ctf_dvdef_t *dvd)
 700 {
 701   if (ctf_dynhash_insert (fp->ctf_dvhash, dvd->dvd_name, dvd) < 0)
 702     return -1;
 703   ctf_list_append (&fp->ctf_dvdefs, dvd);
 704   return 0;
 705 }
 706
 707 void
 708 ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
 709 {
 710   ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name);
 711   free (dvd->dvd_name);
 712
 713   ctf_list_delete (&fp->ctf_dvdefs, dvd);
 714   free (dvd);
 715 }
 716
 717 ctf_dvdef_t *
 718 ctf_dvd_lookup (const ctf_file_t *fp, const char *name)
 719 {
 720   return (ctf_dvdef_t *) ctf_dynhash_lookup (fp->ctf_dvhash, name);
 721 }
 722
 723 /* Discard all of the dynamic type definitions and variable definitions that
 724    have been added to the container since the last call to ctf_update().  We
 725    locate such types by scanning the dtd list and deleting elements that have
 726    type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
 727    by scanning the variable list and deleting elements that have update IDs
 728    equal to the current value of the last-update snapshot count (indicating that
 729    they were added after the most recent call to ctf_update()).  */
 730 int
 731 ctf_discard (ctf_file_t *fp)
 732 {
 733   ctf_snapshot_id_t last_update =
 734     { fp->ctf_dtoldid,
 735       fp->ctf_snapshot_lu + 1 };
 736
 737   /* Update required?  */
 738   if (!(fp->ctf_flags & LCTF_DIRTY))
 739     return 0;
 740
 741   return (ctf_rollback (fp, last_update));
 742 }
 743
 744 ctf_snapshot_id_t
 745 ctf_snapshot (ctf_file_t *fp)
 746 {
 747   ctf_snapshot_id_t snapid;
 748   snapid.dtd_id = fp->ctf_typemax;
 749   snapid.snapshot_id = fp->ctf_snapshots++;
 750   return snapid;
 751 }
 752
 753 /* Like ctf_discard(), only discards everything after a particular ID.  */
 754 int
 755 ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
 756 {
 757   ctf_dtdef_t *dtd, *ntd;
 758   ctf_dvdef_t *dvd, *nvd;
 759
 760   if (!(fp->ctf_flags & LCTF_RDWR))
 761     return (ctf_set_errno (fp, ECTF_RDONLY));
 762
 763   if (fp->ctf_snapshot_lu >= id.snapshot_id)
 764     return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
 765
 766   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
 767     {
 768       int kind;
 769       const char *name;
 770
 771       ntd = ctf_list_next (dtd);
 772
 773       if (LCTF_TYPE_TO_INDEX (fp, dtd->dtd_type) <= id.dtd_id)
 774         continue;
 775
 776       kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
 777       if (kind == CTF_K_FORWARD)
 778         kind = dtd->dtd_data.ctt_type;
 779
 780       if (dtd->dtd_data.ctt_name
 781           && (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL
 782           && LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info))
 783         {
 784           ctf_dynhash_remove (ctf_name_table (fp, kind)->ctn_writable,
 785                               name);
 786           ctf_str_remove_ref (fp, name, &dtd->dtd_data.ctt_name);
 787         }
 788
 789       ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
 790       ctf_dtd_delete (fp, dtd);
 791     }
 792
 793   for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
 794     {
 795       nvd = ctf_list_next (dvd);
 796
 797       if (dvd->dvd_snapshots <= id.snapshot_id)
 798         continue;
 799
 800       ctf_dvd_delete (fp, dvd);
 801     }
 802
 803   fp->ctf_typemax = id.dtd_id;
 804   fp->ctf_snapshots = id.snapshot_id;
 805
 806   if (fp->ctf_snapshots == fp->ctf_snapshot_lu)
 807     fp->ctf_flags &= ~LCTF_DIRTY;
 808
 809   return 0;
 810 }
 811
 812 static ctf_id_t
 813 ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
 814                  ctf_dtdef_t **rp)
 815 {
 816   ctf_dtdef_t *dtd;
 817   ctf_id_t type;
 818
 819   if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
 820     return (ctf_set_errno (fp, EINVAL));
 821
 822   if (!(fp->ctf_flags & LCTF_RDWR))
 823     return (ctf_set_errno (fp, ECTF_RDONLY));
 824
 825   if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) >= CTF_MAX_TYPE)
 826     return (ctf_set_errno (fp, ECTF_FULL));
 827
 828   if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) == (CTF_MAX_PTYPE - 1))
 829     return (ctf_set_errno (fp, ECTF_FULL));
 830
 831   /* Make sure ptrtab always grows to be big enough for all types.  */
 832   if (ctf_grow_ptrtab (fp) < 0)
 833       return CTF_ERR;           /* errno is set for us. */
 834
 835   if ((dtd = malloc (sizeof (ctf_dtdef_t))) == NULL)
 836     return (ctf_set_errno (fp, EAGAIN));
 837
 838   type = ++fp->ctf_typemax;
 839   type = LCTF_INDEX_TO_TYPE (fp, type, (fp->ctf_flags & LCTF_CHILD));
 840
 841   memset (dtd, 0, sizeof (ctf_dtdef_t));
 842   dtd->dtd_data.ctt_name = ctf_str_add_ref (fp, name, &dtd->dtd_data.ctt_name);
 843   dtd->dtd_type = type;
 844
 845   if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
 846     {
 847       free (dtd);
 848       return (ctf_set_errno (fp, EAGAIN));
 849     }
 850
 851   if (ctf_dtd_insert (fp, dtd, flag, kind) < 0)
 852     {
 853       free (dtd);
 854       return CTF_ERR;                   /* errno is set for us.  */
 855     }
 856   fp->ctf_flags |= LCTF_DIRTY;
 857
 858   *rp = dtd;
 859   return type;
 860 }
 861
 862 /* When encoding integer sizes, we want to convert a byte count in the range
 863    1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc).  The clp2() function
 864    is a clever implementation from "Hacker's Delight" by Henry Warren, Jr.  */
 865 static size_t
 866 clp2 (size_t x)
 867 {
 868   x--;
 869
 870   x |= (x >> 1);
 871   x |= (x >> 2);
 872   x |= (x >> 4);
 873   x |= (x >> 8);
 874   x |= (x >> 16);
 875
 876   return (x + 1);
 877 }
 878
 879 static ctf_id_t
 880 ctf_add_encoded (ctf_file_t *fp, uint32_t flag,
 881                  const char *name, const ctf_encoding_t *ep, uint32_t kind)
 882 {
 883   ctf_dtdef_t *dtd;
 884   ctf_id_t type;
 885
 886   if (ep == NULL)
 887     return (ctf_set_errno (fp, EINVAL));
 888
 889   if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
 890     return CTF_ERR;             /* errno is set for us.  */
 891
 892   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
 893   dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
 894                                  / CHAR_BIT);
 895   dtd->dtd_u.dtu_enc = *ep;
 896
 897   return type;
 898 }
 899
 900 static ctf_id_t
 901 ctf_add_reftype (ctf_file_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
 902 {
 903   ctf_dtdef_t *dtd;
 904   ctf_id_t type;
 905   ctf_file_t *tmp = fp;
 906   int child = fp->ctf_flags & LCTF_CHILD;
 907
 908   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
 909     return (ctf_set_errno (fp, EINVAL));
 910
 911   if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
 912     return CTF_ERR;             /* errno is set for us.  */
 913
 914   if ((type = ctf_add_generic (fp, flag, NULL, kind, &dtd)) == CTF_ERR)
 915     return CTF_ERR;             /* errno is set for us.  */
 916
 917   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
 918   dtd->dtd_data.ctt_type = (uint32_t) ref;
 919
 920   if (kind != CTF_K_POINTER)
 921     return type;
 922
 923   /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
 924      type and (if an anonymous typedef node is being pointed at) the type that
 925      points at too.  Note that ctf_typemax is at this point one higher than we
 926      want to check against, because it's just been incremented for the addition
 927      of this type.  */
 928
 929   uint32_t type_idx = LCTF_TYPE_TO_INDEX (fp, type);
 930   uint32_t ref_idx = LCTF_TYPE_TO_INDEX (fp, ref);
 931
 932   if (LCTF_TYPE_ISCHILD (fp, ref) == child
 933       && ref_idx < fp->ctf_typemax)
 934     {
 935       fp->ctf_ptrtab[ref_idx] = type_idx;
 936
 937       ctf_id_t refref_idx = LCTF_TYPE_TO_INDEX (fp, dtd->dtd_data.ctt_type);
 938
 939       if (tmp == fp
 940           && (LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) == CTF_K_TYPEDEF)
 941           && strcmp (ctf_strptr (fp, dtd->dtd_data.ctt_name), "") == 0
 942           && refref_idx < fp->ctf_typemax)
 943         fp->ctf_ptrtab[refref_idx] = type_idx;
 944     }
 945
 946   return type;
 947 }
 948
 949 ctf_id_t
 950 ctf_add_slice (ctf_file_t *fp, uint32_t flag, ctf_id_t ref,
 951                const ctf_encoding_t *ep)
 952 {
 953   ctf_dtdef_t *dtd;
 954   ctf_id_t resolved_ref = ref;
 955   ctf_id_t type;
 956   int kind;
 957   const ctf_type_t *tp;
 958   ctf_file_t *tmp = fp;
 959
 960   if (ep == NULL)
 961     return (ctf_set_errno (fp, EINVAL));
 962
 963   if ((ep->cte_bits > 255) || (ep->cte_offset > 255))
 964     return (ctf_set_errno (fp, ECTF_SLICEOVERFLOW));
 965
 966   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
 967     return (ctf_set_errno (fp, EINVAL));
 968
 969   if (ref != 0 && ((tp = ctf_lookup_by_id (&tmp, ref)) == NULL))
 970     return CTF_ERR;             /* errno is set for us.  */
 971
 972   /* Make sure we ultimately point to an integral type.  We also allow slices to
 973      point to the unimplemented type, for now, because the compiler can emit
 974      such slices, though they're not very much use.  */
 975
 976   resolved_ref = ctf_type_resolve_unsliced (tmp, ref);
 977   kind = ctf_type_kind_unsliced (tmp, resolved_ref);
 978
 979   if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) &&
 980       (kind != CTF_K_ENUM)
 981       && (ref != 0))
 982     return (ctf_set_errno (fp, ECTF_NOTINTFP));
 983
 984   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE, &dtd)) == CTF_ERR)
 985     return CTF_ERR;             /* errno is set for us.  */
 986
 987   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
 988   dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
 989                                  / CHAR_BIT);
 990   dtd->dtd_u.dtu_slice.cts_type = (uint32_t) ref;
 991   dtd->dtd_u.dtu_slice.cts_bits = ep->cte_bits;
 992   dtd->dtd_u.dtu_slice.cts_offset = ep->cte_offset;
 993
 994   return type;
 995 }
 996
 997 ctf_id_t
 998 ctf_add_integer (ctf_file_t *fp, uint32_t flag,
 999                  const char *name, const ctf_encoding_t *ep)
1000 {
1001   return (ctf_add_encoded (fp, flag, name, ep, CTF_K_INTEGER));
1002 }
1003
1004 ctf_id_t
1005 ctf_add_float (ctf_file_t *fp, uint32_t flag,
1006                const char *name, const ctf_encoding_t *ep)
1007 {
1008   return (ctf_add_encoded (fp, flag, name, ep, CTF_K_FLOAT));
1009 }
1010
1011 ctf_id_t
1012 ctf_add_pointer (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1013 {
1014   return (ctf_add_reftype (fp, flag, ref, CTF_K_POINTER));
1015 }
1016
1017 ctf_id_t
1018 ctf_add_array (ctf_file_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
1019 {
1020   ctf_dtdef_t *dtd;
1021   ctf_id_t type;
1022   ctf_file_t *tmp = fp;
1023
1024   if (arp == NULL)
1025     return (ctf_set_errno (fp, EINVAL));
1026
1027   if (arp->ctr_contents != 0
1028       && ctf_lookup_by_id (&tmp, arp->ctr_contents) == NULL)
1029     return CTF_ERR;             /* errno is set for us.  */
1030
1031   tmp = fp;
1032   if (ctf_lookup_by_id (&tmp, arp->ctr_index) == NULL)
1033     return CTF_ERR;             /* errno is set for us.  */
1034
1035   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY, &dtd)) == CTF_ERR)
1036     return CTF_ERR;             /* errno is set for us.  */
1037
1038   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
1039   dtd->dtd_data.ctt_size = 0;
1040   dtd->dtd_u.dtu_arr = *arp;
1041
1042   return type;
1043 }
1044
1045 int
1046 ctf_set_array (ctf_file_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
1047 {
1048   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
1049
1050   if (!(fp->ctf_flags & LCTF_RDWR))
1051     return (ctf_set_errno (fp, ECTF_RDONLY));
1052
1053   if (dtd == NULL
1054       || LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
1055     return (ctf_set_errno (fp, ECTF_BADID));
1056
1057   fp->ctf_flags |= LCTF_DIRTY;
1058   dtd->dtd_u.dtu_arr = *arp;
1059
1060   return 0;
1061 }
1062
1063 ctf_id_t
1064 ctf_add_function (ctf_file_t *fp, uint32_t flag,
1065                   const ctf_funcinfo_t *ctc, const ctf_id_t *argv)
1066 {
1067   ctf_dtdef_t *dtd;
1068   ctf_id_t type;
1069   uint32_t vlen;
1070   uint32_t *vdat = NULL;
1071   ctf_file_t *tmp = fp;
1072   size_t i;
1073
1074   if (ctc == NULL || (ctc->ctc_flags & ~CTF_FUNC_VARARG) != 0
1075       || (ctc->ctc_argc != 0 && argv == NULL))
1076     return (ctf_set_errno (fp, EINVAL));
1077
1078   vlen = ctc->ctc_argc;
1079   if (ctc->ctc_flags & CTF_FUNC_VARARG)
1080     vlen++;            /* Add trailing zero to indicate varargs (see below).  */
1081
1082   if (ctc->ctc_return != 0
1083       && ctf_lookup_by_id (&tmp, ctc->ctc_return) == NULL)
1084     return CTF_ERR;             /* errno is set for us.  */
1085
1086   if (vlen > CTF_MAX_VLEN)
1087     return (ctf_set_errno (fp, EOVERFLOW));
1088
1089   if (vlen != 0 && (vdat = malloc (sizeof (ctf_id_t) * vlen)) == NULL)
1090     return (ctf_set_errno (fp, EAGAIN));
1091
1092   for (i = 0; i < ctc->ctc_argc; i++)
1093     {
1094       tmp = fp;
1095       if (argv[i] != 0 && ctf_lookup_by_id (&tmp, argv[i]) == NULL)
1096         {
1097           free (vdat);
1098           return CTF_ERR;          /* errno is set for us.  */
1099         }
1100       vdat[i] = (uint32_t) argv[i];
1101     }
1102
1103   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
1104                                &dtd)) == CTF_ERR)
1105     {
1106       free (vdat);
1107       return CTF_ERR;              /* errno is set for us.  */
1108     }
1109
1110   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
1111   dtd->dtd_data.ctt_type = (uint32_t) ctc->ctc_return;
1112
1113   if (ctc->ctc_flags & CTF_FUNC_VARARG)
1114     vdat[vlen - 1] = 0;            /* Add trailing zero to indicate varargs.  */
1115   dtd->dtd_u.dtu_argv = vdat;
1116
1117   return type;
1118 }
1119
1120 ctf_id_t
1121 ctf_add_struct_sized (ctf_file_t *fp, uint32_t flag, const char *name,
1122                       size_t size)
1123 {
1124   ctf_dtdef_t *dtd;
1125   ctf_id_t type = 0;
1126
1127   /* Promote root-visible forwards to structs.  */
1128   if (name != NULL)
1129     type = ctf_lookup_by_rawname (fp, CTF_K_STRUCT, name);
1130
1131   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1132     dtd = ctf_dtd_lookup (fp, type);
1133   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_STRUCT,
1134                                     &dtd)) == CTF_ERR)
1135     return CTF_ERR;             /* errno is set for us.  */
1136
1137   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
1138
1139   if (size > CTF_MAX_SIZE)
1140     {
1141       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1142       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1143       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1144     }
1145   else
1146     dtd->dtd_data.ctt_size = (uint32_t) size;
1147
1148   return type;
1149 }
1150
1151 ctf_id_t
1152 ctf_add_struct (ctf_file_t *fp, uint32_t flag, const char *name)
1153 {
1154   return (ctf_add_struct_sized (fp, flag, name, 0));
1155 }
1156
1157 ctf_id_t
1158 ctf_add_union_sized (ctf_file_t *fp, uint32_t flag, const char *name,
1159                      size_t size)
1160 {
1161   ctf_dtdef_t *dtd;
1162   ctf_id_t type = 0;
1163
1164   /* Promote root-visible forwards to unions.  */
1165   if (name != NULL)
1166     type = ctf_lookup_by_rawname (fp, CTF_K_UNION, name);
1167
1168   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1169     dtd = ctf_dtd_lookup (fp, type);
1170   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_UNION,
1171                                     &dtd)) == CTF_ERR)
1172     return CTF_ERR;             /* errno is set for us */
1173
1174   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
1175
1176   if (size > CTF_MAX_SIZE)
1177     {
1178       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1179       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1180       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1181     }
1182   else
1183     dtd->dtd_data.ctt_size = (uint32_t) size;
1184
1185   return type;
1186 }
1187
1188 ctf_id_t
1189 ctf_add_union (ctf_file_t *fp, uint32_t flag, const char *name)
1190 {
1191   return (ctf_add_union_sized (fp, flag, name, 0));
1192 }
1193
1194 ctf_id_t
1195 ctf_add_enum (ctf_file_t *fp, uint32_t flag, const char *name)
1196 {
1197   ctf_dtdef_t *dtd;
1198   ctf_id_t type = 0;
1199
1200   /* Promote root-visible forwards to enums.  */
1201   if (name != NULL)
1202     type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
1203
1204   if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1205     dtd = ctf_dtd_lookup (fp, type);
1206   else if ((type = ctf_add_generic (fp, flag, name, CTF_K_ENUM,
1207                                     &dtd)) == CTF_ERR)
1208     return CTF_ERR;             /* errno is set for us.  */
1209
1210   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
1211   dtd->dtd_data.ctt_size = fp->ctf_dmodel->ctd_int;
1212
1213   return type;
1214 }
1215
1216 ctf_id_t
1217 ctf_add_enum_encoded (ctf_file_t *fp, uint32_t flag, const char *name,
1218                       const ctf_encoding_t *ep)
1219 {
1220   ctf_id_t type = 0;
1221
1222   /* First, create the enum if need be, using most of the same machinery as
1223      ctf_add_enum(), to ensure that we do not allow things past that are not
1224      enums or forwards to them.  (This includes other slices: you cannot slice a
1225      slice, which would be a useless thing to do anyway.)  */
1226
1227   if (name != NULL)
1228     type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
1229
1230   if (type != 0)
1231     {
1232       if ((ctf_type_kind (fp, type) != CTF_K_FORWARD) &&
1233           (ctf_type_kind_unsliced (fp, type) != CTF_K_ENUM))
1234         return (ctf_set_errno (fp, ECTF_NOTINTFP));
1235     }
1236   else if ((type = ctf_add_enum (fp, flag, name)) == CTF_ERR)
1237     return CTF_ERR;             /* errno is set for us.  */
1238
1239   /* Now attach a suitable slice to it.  */
1240
1241   return ctf_add_slice (fp, flag, type, ep);
1242 }
1243
1244 ctf_id_t
1245 ctf_add_forward (ctf_file_t *fp, uint32_t flag, const char *name,
1246                  uint32_t kind)
1247 {
1248   ctf_dtdef_t *dtd;
1249   ctf_id_t type = 0;
1250
1251   if (!ctf_forwardable_kind (kind))
1252     return (ctf_set_errno (fp, ECTF_NOTSUE));
1253
1254   /* If the type is already defined or exists as a forward tag, just
1255      return the ctf_id_t of the existing definition.  */
1256
1257   if (name != NULL)
1258     type = ctf_lookup_by_rawname (fp, kind, name);
1259
1260   if (type)
1261     return type;
1262
1263   if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
1264     return CTF_ERR;             /* errno is set for us.  */
1265
1266   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
1267   dtd->dtd_data.ctt_type = kind;
1268
1269   return type;
1270 }
1271
1272 ctf_id_t
1273 ctf_add_typedef (ctf_file_t *fp, uint32_t flag, const char *name,
1274                  ctf_id_t ref)
1275 {
1276   ctf_dtdef_t *dtd;
1277   ctf_id_t type;
1278   ctf_file_t *tmp = fp;
1279
1280   if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
1281     return (ctf_set_errno (fp, EINVAL));
1282
1283   if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
1284     return CTF_ERR;             /* errno is set for us.  */
1285
1286   if ((type = ctf_add_generic (fp, flag, name, CTF_K_TYPEDEF,
1287                                &dtd)) == CTF_ERR)
1288     return CTF_ERR;             /* errno is set for us.  */
1289
1290   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
1291   dtd->dtd_data.ctt_type = (uint32_t) ref;
1292
1293   return type;
1294 }
1295
1296 ctf_id_t
1297 ctf_add_volatile (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1298 {
1299   return (ctf_add_reftype (fp, flag, ref, CTF_K_VOLATILE));
1300 }
1301
1302 ctf_id_t
1303 ctf_add_const (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1304 {
1305   return (ctf_add_reftype (fp, flag, ref, CTF_K_CONST));
1306 }
1307
1308 ctf_id_t
1309 ctf_add_restrict (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1310 {
1311   return (ctf_add_reftype (fp, flag, ref, CTF_K_RESTRICT));
1312 }
1313
1314 int
1315 ctf_add_enumerator (ctf_file_t *fp, ctf_id_t enid, const char *name,
1316                     int value)
1317 {
1318   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, enid);
1319   ctf_dmdef_t *dmd;
1320
1321   uint32_t kind, vlen, root;
1322   char *s;
1323
1324   if (name == NULL)
1325     return (ctf_set_errno (fp, EINVAL));
1326
1327   if (!(fp->ctf_flags & LCTF_RDWR))
1328     return (ctf_set_errno (fp, ECTF_RDONLY));
1329
1330   if (dtd == NULL)
1331     return (ctf_set_errno (fp, ECTF_BADID));
1332
1333   kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1334   root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1335   vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1336
1337   if (kind != CTF_K_ENUM)
1338     return (ctf_set_errno (fp, ECTF_NOTENUM));
1339
1340   if (vlen == CTF_MAX_VLEN)
1341     return (ctf_set_errno (fp, ECTF_DTFULL));
1342
1343   for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1344        dmd != NULL; dmd = ctf_list_next (dmd))
1345     {
1346       if (strcmp (dmd->dmd_name, name) == 0)
1347         return (ctf_set_errno (fp, ECTF_DUPLICATE));
1348     }
1349
1350   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1351     return (ctf_set_errno (fp, EAGAIN));
1352
1353   if ((s = strdup (name)) == NULL)
1354     {
1355       free (dmd);
1356       return (ctf_set_errno (fp, EAGAIN));
1357     }
1358
1359   dmd->dmd_name = s;
1360   dmd->dmd_type = CTF_ERR;
1361   dmd->dmd_offset = 0;
1362   dmd->dmd_value = value;
1363
1364   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1365   ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1366
1367   fp->ctf_flags |= LCTF_DIRTY;
1368
1369   return 0;
1370 }
1371
1372 int
1373 ctf_add_member_offset (ctf_file_t *fp, ctf_id_t souid, const char *name,
1374                        ctf_id_t type, unsigned long bit_offset)
1375 {
1376   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, souid);
1377   ctf_dmdef_t *dmd;
1378
1379   ssize_t msize, malign, ssize;
1380   uint32_t kind, vlen, root;
1381   char *s = NULL;
1382
1383   if (!(fp->ctf_flags & LCTF_RDWR))
1384     return (ctf_set_errno (fp, ECTF_RDONLY));
1385
1386   if (dtd == NULL)
1387     return (ctf_set_errno (fp, ECTF_BADID));
1388
1389   if (name != NULL && name[0] == '\0')
1390     name = NULL;
1391
1392   kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1393   root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1394   vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1395
1396   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
1397     return (ctf_set_errno (fp, ECTF_NOTSOU));
1398
1399   if (vlen == CTF_MAX_VLEN)
1400     return (ctf_set_errno (fp, ECTF_DTFULL));
1401
1402   if (name != NULL)
1403     {
1404       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1405            dmd != NULL; dmd = ctf_list_next (dmd))
1406         {
1407           if (dmd->dmd_name != NULL && strcmp (dmd->dmd_name, name) == 0)
1408             return (ctf_set_errno (fp, ECTF_DUPLICATE));
1409         }
1410     }
1411
1412   if ((msize = ctf_type_size (fp, type)) < 0 ||
1413       (malign = ctf_type_align (fp, type)) < 0)
1414     {
1415       /* The unimplemented type, and any type that resolves to it, has no size
1416          and no alignment: it can correspond to any number of compiler-inserted
1417          types.  */
1418
1419       if (ctf_errno (fp) == ECTF_NONREPRESENTABLE)
1420         {
1421           msize = 0;
1422           malign = 0;
1423           ctf_set_errno (fp, 0);
1424         }
1425       else
1426         return -1;              /* errno is set for us.  */
1427     }
1428
1429   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1430     return (ctf_set_errno (fp, EAGAIN));
1431
1432   if (name != NULL && (s = strdup (name)) == NULL)
1433     {
1434       free (dmd);
1435       return (ctf_set_errno (fp, EAGAIN));
1436     }
1437
1438   dmd->dmd_name = s;
1439   dmd->dmd_type = type;
1440   dmd->dmd_value = -1;
1441
1442   if (kind == CTF_K_STRUCT && vlen != 0)
1443     {
1444       if (bit_offset == (unsigned long) - 1)
1445         {
1446           /* Natural alignment.  */
1447
1448           ctf_dmdef_t *lmd = ctf_list_prev (&dtd->dtd_u.dtu_members);
1449           ctf_id_t ltype = ctf_type_resolve (fp, lmd->dmd_type);
1450           size_t off = lmd->dmd_offset;
1451
1452           ctf_encoding_t linfo;
1453           ssize_t lsize;
1454
1455           /* Propagate any error from ctf_type_resolve.  If the last member was
1456              of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1457              cannot insert right after such a member without explicit offset
1458              specification, because its alignment and size is not known.  */
1459           if (ltype == CTF_ERR)
1460             {
1461               free (dmd);
1462               return -1;        /* errno is set for us.  */
1463             }
1464
1465           if (ctf_type_encoding (fp, ltype, &linfo) == 0)
1466             off += linfo.cte_bits;
1467           else if ((lsize = ctf_type_size (fp, ltype)) > 0)
1468             off += lsize * CHAR_BIT;
1469
1470           /* Round up the offset of the end of the last member to
1471              the next byte boundary, convert 'off' to bytes, and
1472              then round it up again to the next multiple of the
1473              alignment required by the new member.  Finally,
1474              convert back to bits and store the result in
1475              dmd_offset.  Technically we could do more efficient
1476              packing if the new member is a bit-field, but we're
1477              the "compiler" and ANSI says we can do as we choose.  */
1478
1479           off = roundup (off, CHAR_BIT) / CHAR_BIT;
1480           off = roundup (off, MAX (malign, 1));
1481           dmd->dmd_offset = off * CHAR_BIT;
1482           ssize = off + msize;
1483         }
1484       else
1485         {
1486           /* Specified offset in bits.  */
1487
1488           dmd->dmd_offset = bit_offset;
1489           ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1490           ssize = MAX (ssize, ((signed) bit_offset / CHAR_BIT) + msize);
1491         }
1492     }
1493   else
1494     {
1495       dmd->dmd_offset = 0;
1496       ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1497       ssize = MAX (ssize, msize);
1498     }
1499
1500   if ((size_t) ssize > CTF_MAX_SIZE)
1501     {
1502       dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1503       dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (ssize);
1504       dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (ssize);
1505     }
1506   else
1507     dtd->dtd_data.ctt_size = (uint32_t) ssize;
1508
1509   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1510   ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1511
1512   fp->ctf_flags |= LCTF_DIRTY;
1513   return 0;
1514 }
1515
1516 int
1517 ctf_add_member_encoded (ctf_file_t *fp, ctf_id_t souid, const char *name,
1518                         ctf_id_t type, unsigned long bit_offset,
1519                         const ctf_encoding_t encoding)
1520 {
1521   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
1522   int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1523   int otype = type;
1524
1525   if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) && (kind != CTF_K_ENUM))
1526     return (ctf_set_errno (fp, ECTF_NOTINTFP));
1527
1528   if ((type = ctf_add_slice (fp, CTF_ADD_NONROOT, otype, &encoding)) == CTF_ERR)
1529     return -1;                  /* errno is set for us.  */
1530
1531   return ctf_add_member_offset (fp, souid, name, type, bit_offset);
1532 }
1533
1534 int
1535 ctf_add_member (ctf_file_t *fp, ctf_id_t souid, const char *name,
1536                 ctf_id_t type)
1537 {
1538   return ctf_add_member_offset (fp, souid, name, type, (unsigned long) - 1);
1539 }
1540
1541 int
1542 ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
1543 {
1544   ctf_dvdef_t *dvd;
1545   ctf_file_t *tmp = fp;
1546
1547   if (!(fp->ctf_flags & LCTF_RDWR))
1548     return (ctf_set_errno (fp, ECTF_RDONLY));
1549
1550   if (ctf_dvd_lookup (fp, name) != NULL)
1551     return (ctf_set_errno (fp, ECTF_DUPLICATE));
1552
1553   if (ctf_lookup_by_id (&tmp, ref) == NULL)
1554     return -1;                  /* errno is set for us.  */
1555
1556   /* Make sure this type is representable.  */
1557   if ((ctf_type_resolve (fp, ref) == CTF_ERR)
1558       && (ctf_errno (fp) == ECTF_NONREPRESENTABLE))
1559     return -1;
1560
1561   if ((dvd = malloc (sizeof (ctf_dvdef_t))) == NULL)
1562     return (ctf_set_errno (fp, EAGAIN));
1563
1564   if (name != NULL && (dvd->dvd_name = strdup (name)) == NULL)
1565     {
1566       free (dvd);
1567       return (ctf_set_errno (fp, EAGAIN));
1568     }
1569   dvd->dvd_type = ref;
1570   dvd->dvd_snapshots = fp->ctf_snapshots;
1571
1572   if (ctf_dvd_insert (fp, dvd) < 0)
1573     {
1574       free (dvd->dvd_name);
1575       free (dvd);
1576       return -1;                        /* errno is set for us.  */
1577     }
1578
1579   fp->ctf_flags |= LCTF_DIRTY;
1580   return 0;
1581 }
1582
1583 static int
1584 enumcmp (const char *name, int value, void *arg)
1585 {
1586   ctf_bundle_t *ctb = arg;
1587   int bvalue;
1588
1589   if (ctf_enum_value (ctb->ctb_file, ctb->ctb_type, name, &bvalue) < 0)
1590     {
1591       ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name,
1592                    ctf_errmsg (ctf_errno (ctb->ctb_file)));
1593       return 1;
1594     }
1595   if (value != bvalue)
1596     {
1597       ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1598                    value, bvalue);
1599       return 1;
1600     }
1601   return 0;
1602 }
1603
1604 static int
1605 enumadd (const char *name, int value, void *arg)
1606 {
1607   ctf_bundle_t *ctb = arg;
1608
1609   return (ctf_add_enumerator (ctb->ctb_file, ctb->ctb_type,
1610                               name, value) < 0);
1611 }
1612
1613 static int
1614 membcmp (const char *name, ctf_id_t type _libctf_unused_, unsigned long offset,
1615          void *arg)
1616 {
1617   ctf_bundle_t *ctb = arg;
1618   ctf_membinfo_t ctm;
1619
1620   /* Don't check nameless members (e.g. anonymous structs/unions) against each
1621      other.  */
1622   if (name[0] == 0)
1623     return 0;
1624
1625   if (ctf_member_info (ctb->ctb_file, ctb->ctb_type, name, &ctm) < 0)
1626     {
1627       ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name,
1628                    ctf_errmsg (ctf_errno (ctb->ctb_file)));
1629       return 1;
1630     }
1631   if (ctm.ctm_offset != offset)
1632     {
1633       ctf_dprintf ("Conflict due to member %s offset change: "
1634                    "%lx versus %lx\n", name, ctm.ctm_offset, offset);
1635       return 1;
1636     }
1637   return 0;
1638 }
1639
1640 static int
1641 membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
1642 {
1643   ctf_bundle_t *ctb = arg;
1644   ctf_dmdef_t *dmd;
1645   char *s = NULL;
1646
1647   if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
1648     return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1649
1650   if (name != NULL && (s = strdup (name)) == NULL)
1651     {
1652       free (dmd);
1653       return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1654     }
1655
1656   /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1657     equivalent dst_fp type by a final loop in ctf_add_type(), below.  */
1658   dmd->dmd_name = s;
1659   dmd->dmd_type = type;
1660   dmd->dmd_offset = offset;
1661   dmd->dmd_value = -1;
1662
1663   ctf_list_append (&ctb->ctb_dtd->dtd_u.dtu_members, dmd);
1664
1665   ctb->ctb_file->ctf_flags |= LCTF_DIRTY;
1666   return 0;
1667 }
1668
1669 /* The ctf_add_type routine is used to copy a type from a source CTF container
1670    to a dynamic destination container.  This routine operates recursively by
1671    following the source type's links and embedded member types.  If the
1672    destination container already contains a named type which has the same
1673    attributes, then we succeed and return this type but no changes occur.  */
1674 static ctf_id_t
1675 ctf_add_type_internal (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type,
1676                        ctf_file_t *proc_tracking_fp)
1677 {
1678   ctf_id_t dst_type = CTF_ERR;
1679   uint32_t dst_kind = CTF_K_UNKNOWN;
1680   ctf_file_t *tmp_fp = dst_fp;
1681   ctf_id_t tmp;
1682
1683   const char *name;
1684   uint32_t kind, forward_kind, flag, vlen;
1685
1686   const ctf_type_t *src_tp, *dst_tp;
1687   ctf_bundle_t src, dst;
1688   ctf_encoding_t src_en, dst_en;
1689   ctf_arinfo_t src_ar, dst_ar;
1690
1691   ctf_funcinfo_t ctc;
1692
1693   ctf_id_t orig_src_type = src_type;
1694
1695   if (!(dst_fp->ctf_flags & LCTF_RDWR))
1696     return (ctf_set_errno (dst_fp, ECTF_RDONLY));
1697
1698   if ((src_tp = ctf_lookup_by_id (&src_fp, src_type)) == NULL)
1699     return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1700
1701   if ((ctf_type_resolve (src_fp, src_type) == CTF_ERR)
1702       && (ctf_errno (src_fp) == ECTF_NONREPRESENTABLE))
1703     return (ctf_set_errno (dst_fp, ECTF_NONREPRESENTABLE));
1704
1705   name = ctf_strptr (src_fp, src_tp->ctt_name);
1706   kind = LCTF_INFO_KIND (src_fp, src_tp->ctt_info);
1707   flag = LCTF_INFO_ISROOT (src_fp, src_tp->ctt_info);
1708   vlen = LCTF_INFO_VLEN (src_fp, src_tp->ctt_info);
1709
1710   /* If this is a type we are currently in the middle of adding, hand it
1711      straight back.  (This lets us handle self-referential structures without
1712      considering forwards and empty structures the same as their completed
1713      forms.)  */
1714
1715   tmp = ctf_type_mapping (src_fp, src_type, &tmp_fp);
1716
1717   if (tmp != 0)
1718     {
1719       if (ctf_dynhash_lookup (proc_tracking_fp->ctf_add_processing,
1720                               (void *) (uintptr_t) src_type))
1721         return tmp;
1722
1723       /* If this type has already been added from this container, and is the same
1724          kind and (if a struct or union) has the same number of members, hand it
1725          straight back.  */
1726
1727       if (ctf_type_kind_unsliced (tmp_fp, tmp) == (int) kind)
1728         {
1729           if (kind == CTF_K_STRUCT || kind == CTF_K_UNION
1730               || kind == CTF_K_ENUM)
1731             {
1732               if ((dst_tp = ctf_lookup_by_id (&tmp_fp, dst_type)) != NULL)
1733                 if (vlen == LCTF_INFO_VLEN (tmp_fp, dst_tp->ctt_info))
1734                   return tmp;
1735             }
1736           else
1737             return tmp;
1738         }
1739     }
1740
1741   forward_kind = kind;
1742   if (kind == CTF_K_FORWARD)
1743     forward_kind = src_tp->ctt_type;
1744
1745   /* If the source type has a name and is a root type (visible at the
1746      top-level scope), lookup the name in the destination container and
1747      verify that it is of the same kind before we do anything else.  */
1748
1749   if ((flag & CTF_ADD_ROOT) && name[0] != '\0'
1750       && (tmp = ctf_lookup_by_rawname (dst_fp, forward_kind, name)) != 0)
1751     {
1752       dst_type = tmp;
1753       dst_kind = ctf_type_kind_unsliced (dst_fp, dst_type);
1754     }
1755
1756   /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1757      unless dst_type is a forward declaration and src_type is a struct,
1758      union, or enum (i.e. the definition of the previous forward decl).
1759
1760      We also allow addition in the opposite order (addition of a forward when a
1761      struct, union, or enum already exists), which is a NOP and returns the
1762      already-present struct, union, or enum.  */
1763
1764   if (dst_type != CTF_ERR && dst_kind != kind)
1765     {
1766       if (kind == CTF_K_FORWARD
1767           && (dst_kind == CTF_K_ENUM || dst_kind == CTF_K_STRUCT
1768               || dst_kind == CTF_K_UNION))
1769         {
1770           ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1771           return dst_type;
1772         }
1773
1774       if (dst_kind != CTF_K_FORWARD
1775           || (kind != CTF_K_ENUM && kind != CTF_K_STRUCT
1776               && kind != CTF_K_UNION))
1777         {
1778           ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1779                        "old (ID %lx): %i\n", name, kind, dst_type, dst_kind);
1780           return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1781         }
1782     }
1783
1784   /* We take special action for an integer, float, or slice since it is
1785      described not only by its name but also its encoding.  For integers,
1786      bit-fields exploit this degeneracy.  */
1787
1788   if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT || kind == CTF_K_SLICE)
1789     {
1790       if (ctf_type_encoding (src_fp, src_type, &src_en) != 0)
1791         return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1792
1793       if (dst_type != CTF_ERR)
1794         {
1795           ctf_file_t *fp = dst_fp;
1796
1797           if ((dst_tp = ctf_lookup_by_id (&fp, dst_type)) == NULL)
1798             return CTF_ERR;
1799
1800           if (ctf_type_encoding (dst_fp, dst_type, &dst_en) != 0)
1801             return CTF_ERR;                     /* errno set for us.  */
1802
1803           if (LCTF_INFO_ISROOT (fp, dst_tp->ctt_info) & CTF_ADD_ROOT)
1804             {
1805               /* The type that we found in the hash is also root-visible.  If
1806                  the two types match then use the existing one; otherwise,
1807                  declare a conflict.  Note: slices are not certain to match
1808                  even if there is no conflict: we must check the contained type
1809                  too.  */
1810
1811               if (memcmp (&src_en, &dst_en, sizeof (ctf_encoding_t)) == 0)
1812                 {
1813                   if (kind != CTF_K_SLICE)
1814                     {
1815                       ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1816                       return dst_type;
1817                     }
1818                 }
1819               else
1820                   {
1821                     return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1822                   }
1823             }
1824           else
1825             {
1826               /* We found a non-root-visible type in the hash.  If its encoding
1827                  is the same, we can reuse it, unless it is a slice.  */
1828
1829               if (memcmp (&src_en, &dst_en, sizeof (ctf_encoding_t)) == 0)
1830                 {
1831                   if (kind != CTF_K_SLICE)
1832                     {
1833                       ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
1834                       return dst_type;
1835                     }
1836                 }
1837             }
1838         }
1839     }
1840
1841   src.ctb_file = src_fp;
1842   src.ctb_type = src_type;
1843   src.ctb_dtd = NULL;
1844
1845   dst.ctb_file = dst_fp;
1846   dst.ctb_type = dst_type;
1847   dst.ctb_dtd = NULL;
1848
1849   /* Now perform kind-specific processing.  If dst_type is CTF_ERR, then we add
1850      a new type with the same properties as src_type to dst_fp.  If dst_type is
1851      not CTF_ERR, then we verify that dst_type has the same attributes as
1852      src_type.  We recurse for embedded references.  Before we start, we note
1853      that we are processing this type, to prevent infinite recursion: we do not
1854      re-process any type that appears in this list.  The list is emptied
1855      wholesale at the end of processing everything in this recursive stack.  */
1856
1857   if (ctf_dynhash_insert (proc_tracking_fp->ctf_add_processing,
1858                           (void *) (uintptr_t) src_type, (void *) 1) < 0)
1859     return ctf_set_errno (dst_fp, ENOMEM);
1860
1861   switch (kind)
1862     {
1863     case CTF_K_INTEGER:
1864       /*  If we found a match we will have either returned it or declared a
1865           conflict.  */
1866       dst_type = ctf_add_integer (dst_fp, flag, name, &src_en);
1867       break;
1868
1869     case CTF_K_FLOAT:
1870       /* If we found a match we will have either returned it or declared a
1871        conflict.  */
1872       dst_type = ctf_add_float (dst_fp, flag, name, &src_en);
1873       break;
1874
1875     case CTF_K_SLICE:
1876       /* We have checked for conflicting encodings: now try to add the
1877          contained type.  */
1878       src_type = ctf_type_reference (src_fp, src_type);
1879       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
1880                                         proc_tracking_fp);
1881
1882       if (src_type == CTF_ERR)
1883         return CTF_ERR;                         /* errno is set for us.  */
1884
1885       dst_type = ctf_add_slice (dst_fp, flag, src_type, &src_en);
1886       break;
1887
1888     case CTF_K_POINTER:
1889     case CTF_K_VOLATILE:
1890     case CTF_K_CONST:
1891     case CTF_K_RESTRICT:
1892       src_type = ctf_type_reference (src_fp, src_type);
1893       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
1894                                         proc_tracking_fp);
1895
1896       if (src_type == CTF_ERR)
1897         return CTF_ERR;                         /* errno is set for us.  */
1898
1899       dst_type = ctf_add_reftype (dst_fp, flag, src_type, kind);
1900       break;
1901
1902     case CTF_K_ARRAY:
1903       if (ctf_array_info (src_fp, src_type, &src_ar) != 0)
1904         return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1905
1906       src_ar.ctr_contents =
1907         ctf_add_type_internal (dst_fp, src_fp, src_ar.ctr_contents,
1908                                proc_tracking_fp);
1909       src_ar.ctr_index = ctf_add_type_internal (dst_fp, src_fp,
1910                                                 src_ar.ctr_index,
1911                                                 proc_tracking_fp);
1912       src_ar.ctr_nelems = src_ar.ctr_nelems;
1913
1914       if (src_ar.ctr_contents == CTF_ERR || src_ar.ctr_index == CTF_ERR)
1915         return CTF_ERR;                         /* errno is set for us.  */
1916
1917       if (dst_type != CTF_ERR)
1918         {
1919           if (ctf_array_info (dst_fp, dst_type, &dst_ar) != 0)
1920             return CTF_ERR;                     /* errno is set for us.  */
1921
1922           if (memcmp (&src_ar, &dst_ar, sizeof (ctf_arinfo_t)))
1923             {
1924               ctf_dprintf ("Conflict for type %s against ID %lx: "
1925                            "array info differs, old %lx/%lx/%x; "
1926                            "new: %lx/%lx/%x\n", name, dst_type,
1927                            src_ar.ctr_contents, src_ar.ctr_index,
1928                            src_ar.ctr_nelems, dst_ar.ctr_contents,
1929                            dst_ar.ctr_index, dst_ar.ctr_nelems);
1930               return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1931             }
1932         }
1933       else
1934         dst_type = ctf_add_array (dst_fp, flag, &src_ar);
1935       break;
1936
1937     case CTF_K_FUNCTION:
1938       ctc.ctc_return = ctf_add_type_internal (dst_fp, src_fp,
1939                                               src_tp->ctt_type,
1940                                               proc_tracking_fp);
1941       ctc.ctc_argc = 0;
1942       ctc.ctc_flags = 0;
1943
1944       if (ctc.ctc_return == CTF_ERR)
1945         return CTF_ERR;                         /* errno is set for us.  */
1946
1947       dst_type = ctf_add_function (dst_fp, flag, &ctc, NULL);
1948       break;
1949
1950     case CTF_K_STRUCT:
1951     case CTF_K_UNION:
1952       {
1953         ctf_dmdef_t *dmd;
1954         int errs = 0;
1955         size_t size;
1956         ssize_t ssize;
1957         ctf_dtdef_t *dtd;
1958
1959         /* Technically to match a struct or union we need to check both
1960            ways (src members vs. dst, dst members vs. src) but we make
1961            this more optimal by only checking src vs. dst and comparing
1962            the total size of the structure (which we must do anyway)
1963            which covers the possibility of dst members not in src.
1964            This optimization can be defeated for unions, but is so
1965            pathological as to render it irrelevant for our purposes.  */
1966
1967         if (dst_type != CTF_ERR && kind != CTF_K_FORWARD
1968             && dst_kind != CTF_K_FORWARD)
1969           {
1970             if (ctf_type_size (src_fp, src_type) !=
1971                 ctf_type_size (dst_fp, dst_type))
1972               {
1973                 ctf_dprintf ("Conflict for type %s against ID %lx: "
1974                              "union size differs, old %li, new %li\n",
1975                              name, dst_type,
1976                              (long) ctf_type_size (src_fp, src_type),
1977                              (long) ctf_type_size (dst_fp, dst_type));
1978                 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1979               }
1980
1981             if (ctf_member_iter (src_fp, src_type, membcmp, &dst))
1982               {
1983                 ctf_dprintf ("Conflict for type %s against ID %lx: "
1984                              "members differ, see above\n", name, dst_type);
1985                 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1986               }
1987
1988             break;
1989           }
1990
1991         /* Unlike the other cases, copying structs and unions is done
1992            manually so as to avoid repeated lookups in ctf_add_member
1993            and to ensure the exact same member offsets as in src_type.  */
1994
1995         dst_type = ctf_add_generic (dst_fp, flag, name, kind, &dtd);
1996         if (dst_type == CTF_ERR)
1997           return CTF_ERR;                       /* errno is set for us.  */
1998
1999         dst.ctb_type = dst_type;
2000         dst.ctb_dtd = dtd;
2001
2002         /* Pre-emptively add this struct to the type mapping so that
2003            structures that refer to themselves work.  */
2004         ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
2005
2006         if (ctf_member_iter (src_fp, src_type, membadd, &dst) != 0)
2007           errs++;              /* Increment errs and fail at bottom of case.  */
2008
2009         if ((ssize = ctf_type_size (src_fp, src_type)) < 0)
2010           return CTF_ERR;                       /* errno is set for us.  */
2011
2012         size = (size_t) ssize;
2013         if (size > CTF_MAX_SIZE)
2014           {
2015             dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
2016             dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
2017             dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
2018           }
2019         else
2020           dtd->dtd_data.ctt_size = (uint32_t) size;
2021
2022         dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, vlen);
2023
2024         /* Make a final pass through the members changing each dmd_type (a
2025            src_fp type) to an equivalent type in dst_fp.  We pass through all
2026            members, leaving any that fail set to CTF_ERR, unless they fail
2027            because they are marking a member of type not representable in this
2028            version of CTF, in which case we just want to silently omit them:
2029            no consumer can do anything with them anyway.  */
2030         for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
2031              dmd != NULL; dmd = ctf_list_next (dmd))
2032           {
2033             ctf_file_t *dst = dst_fp;
2034             ctf_id_t memb_type;
2035
2036             memb_type = ctf_type_mapping (src_fp, dmd->dmd_type, &dst);
2037             if (memb_type == 0)
2038               {
2039                 if ((dmd->dmd_type =
2040                      ctf_add_type_internal (dst_fp, src_fp, dmd->dmd_type,
2041                                             proc_tracking_fp)) == CTF_ERR)
2042                   {
2043                     if (ctf_errno (dst_fp) != ECTF_NONREPRESENTABLE)
2044                       errs++;
2045                   }
2046               }
2047             else
2048               dmd->dmd_type = memb_type;
2049           }
2050
2051         if (errs)
2052           return CTF_ERR;                       /* errno is set for us.  */
2053         break;
2054       }
2055
2056     case CTF_K_ENUM:
2057       if (dst_type != CTF_ERR && kind != CTF_K_FORWARD
2058           && dst_kind != CTF_K_FORWARD)
2059         {
2060           if (ctf_enum_iter (src_fp, src_type, enumcmp, &dst)
2061               || ctf_enum_iter (dst_fp, dst_type, enumcmp, &src))
2062             {
2063               ctf_dprintf ("Conflict for enum %s against ID %lx: "
2064                            "members differ, see above\n", name, dst_type);
2065               return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
2066             }
2067         }
2068       else
2069         {
2070           dst_type = ctf_add_enum (dst_fp, flag, name);
2071           if ((dst.ctb_type = dst_type) == CTF_ERR
2072               || ctf_enum_iter (src_fp, src_type, enumadd, &dst))
2073             return CTF_ERR;                     /* errno is set for us */
2074         }
2075       break;
2076
2077     case CTF_K_FORWARD:
2078       if (dst_type == CTF_ERR)
2079           dst_type = ctf_add_forward (dst_fp, flag, name, forward_kind);
2080       break;
2081
2082     case CTF_K_TYPEDEF:
2083       src_type = ctf_type_reference (src_fp, src_type);
2084       src_type = ctf_add_type_internal (dst_fp, src_fp, src_type,
2085                                         proc_tracking_fp);
2086
2087       if (src_type == CTF_ERR)
2088         return CTF_ERR;                         /* errno is set for us.  */
2089
2090       /* If dst_type is not CTF_ERR at this point, we should check if
2091          ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2092          ECTF_CONFLICT.  However, this causes problems with bitness typedefs
2093          that vary based on things like if 32-bit then pid_t is int otherwise
2094          long.  We therefore omit this check and assume that if the identically
2095          named typedef already exists in dst_fp, it is correct or
2096          equivalent.  */
2097
2098       if (dst_type == CTF_ERR)
2099           dst_type = ctf_add_typedef (dst_fp, flag, name, src_type);
2100
2101       break;
2102
2103     default:
2104       return (ctf_set_errno (dst_fp, ECTF_CORRUPT));
2105     }
2106
2107   if (dst_type != CTF_ERR)
2108     ctf_add_type_mapping (src_fp, orig_src_type, dst_fp, dst_type);
2109   return dst_type;
2110 }
2111
2112 ctf_id_t
2113 ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
2114 {
2115   ctf_id_t id;
2116
2117   if (!src_fp->ctf_add_processing)
2118     src_fp->ctf_add_processing = ctf_dynhash_create (ctf_hash_integer,
2119                                                      ctf_hash_eq_integer,
2120                                                      NULL, NULL);
2121
2122   /* We store the hash on the source, because it contains only source type IDs:
2123      but callers will invariably expect errors to appear on the dest.  */
2124   if (!src_fp->ctf_add_processing)
2125     return (ctf_set_errno (dst_fp, ENOMEM));
2126
2127   id = ctf_add_type_internal (dst_fp, src_fp, src_type, src_fp);
2128   ctf_dynhash_empty (src_fp->ctf_add_processing);
2129
2130   return id;
2131 }
2132
2133 /* Write the compressed CTF data stream to the specified gzFile descriptor.  */
2134 int
2135 ctf_gzwrite (ctf_file_t *fp, gzFile fd)
2136 {
2137   const unsigned char *buf;
2138   ssize_t resid;
2139   ssize_t len;
2140
2141   resid = sizeof (ctf_header_t);
2142   buf = (unsigned char *) fp->ctf_header;
2143   while (resid != 0)
2144     {
2145       if ((len = gzwrite (fd, buf, resid)) <= 0)
2146         return (ctf_set_errno (fp, errno));
2147       resid -= len;
2148       buf += len;
2149     }
2150
2151   resid = fp->ctf_size;
2152   buf = fp->ctf_buf;
2153   while (resid != 0)
2154     {
2155       if ((len = gzwrite (fd, buf, resid)) <= 0)
2156         return (ctf_set_errno (fp, errno));
2157       resid -= len;
2158       buf += len;
2159     }
2160
2161   return 0;
2162 }
2163
2164 /* Compress the specified CTF data stream and write it to the specified file
2165    descriptor.  */
2166 int
2167 ctf_compress_write (ctf_file_t *fp, int fd)
2168 {
2169   unsigned char *buf;
2170   unsigned char *bp;
2171   ctf_header_t h;
2172   ctf_header_t *hp = &h;
2173   ssize_t header_len = sizeof (ctf_header_t);
2174   ssize_t compress_len;
2175   ssize_t len;
2176   int rc;
2177   int err = 0;
2178
2179   if (ctf_serialize (fp) < 0)
2180     return -1;                                  /* errno is set for us.  */
2181
2182   memcpy (hp, fp->ctf_header, header_len);
2183   hp->cth_flags |= CTF_F_COMPRESS;
2184   compress_len = compressBound (fp->ctf_size);
2185
2186   if ((buf = malloc (compress_len)) == NULL)
2187     return (ctf_set_errno (fp, ECTF_ZALLOC));
2188
2189   if ((rc = compress (buf, (uLongf *) &compress_len,
2190                       fp->ctf_buf, fp->ctf_size)) != Z_OK)
2191     {
2192       ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
2193       err = ctf_set_errno (fp, ECTF_COMPRESS);
2194       goto ret;
2195     }
2196
2197   while (header_len > 0)
2198     {
2199       if ((len = write (fd, hp, header_len)) < 0)
2200         {
2201           err = ctf_set_errno (fp, errno);
2202           goto ret;
2203         }
2204       header_len -= len;
2205       hp += len;
2206     }
2207
2208   bp = buf;
2209   while (compress_len > 0)
2210     {
2211       if ((len = write (fd, bp, compress_len)) < 0)
2212         {
2213           err = ctf_set_errno (fp, errno);
2214           goto ret;
2215         }
2216       compress_len -= len;
2217       bp += len;
2218     }
2219
2220 ret:
2221   free (buf);
2222   return err;
2223 }
2224
2225 /* Optionally compress the specified CTF data stream and return it as a new
2226    dynamically-allocated string.  */
2227 unsigned char *
2228 ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
2229 {
2230   unsigned char *buf;
2231   unsigned char *bp;
2232   ctf_header_t *hp;
2233   ssize_t header_len = sizeof (ctf_header_t);
2234   ssize_t compress_len;
2235   int rc;
2236
2237   if (ctf_serialize (fp) < 0)
2238     return NULL;                                /* errno is set for us.  */
2239
2240   compress_len = compressBound (fp->ctf_size);
2241   if (fp->ctf_size < threshold)
2242     compress_len = fp->ctf_size;
2243   if ((buf = malloc (compress_len
2244                      + sizeof (struct ctf_header))) == NULL)
2245     {
2246       ctf_set_errno (fp, ENOMEM);
2247       return NULL;
2248     }
2249
2250   hp = (ctf_header_t *) buf;
2251   memcpy (hp, fp->ctf_header, header_len);
2252   bp = buf + sizeof (struct ctf_header);
2253   *size = sizeof (struct ctf_header);
2254
2255   if (fp->ctf_size < threshold)
2256     {
2257       hp->cth_flags &= ~CTF_F_COMPRESS;
2258       memcpy (bp, fp->ctf_buf, fp->ctf_size);
2259       *size += fp->ctf_size;
2260     }
2261   else
2262     {
2263       hp->cth_flags |= CTF_F_COMPRESS;
2264       if ((rc = compress (bp, (uLongf *) &compress_len,
2265                           fp->ctf_buf, fp->ctf_size)) != Z_OK)
2266         {
2267           ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
2268           ctf_set_errno (fp, ECTF_COMPRESS);
2269           free (buf);
2270           return NULL;
2271         }
2272       *size += compress_len;
2273     }
2274   return buf;
2275 }
2276
2277 /* Write the uncompressed CTF data stream to the specified file descriptor.  */
2278 int
2279 ctf_write (ctf_file_t *fp, int fd)
2280 {
2281   const unsigned char *buf;
2282   ssize_t resid;
2283   ssize_t len;
2284
2285   if (ctf_serialize (fp) < 0)
2286     return -1;                                  /* errno is set for us.  */
2287
2288   resid = sizeof (ctf_header_t);
2289   buf = (unsigned char *) fp->ctf_header;
2290   while (resid != 0)
2291     {
2292       if ((len = write (fd, buf, resid)) <= 0)
2293         return (ctf_set_errno (fp, errno));
2294       resid -= len;
2295       buf += len;
2296     }
2297
2298   resid = fp->ctf_size;
2299   buf = fp->ctf_buf;
2300   while (resid != 0)
2301     {
2302       if ((len = write (fd, buf, resid)) <= 0)
2303         return (ctf_set_errno (fp, errno));
2304       resid -= len;
2305       buf += len;
2306     }
2307
2308   return 0;
2309 }