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