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