2 Copyright (C) 2019 Free Software Foundation, Inc.
4 This file is part of libctf.
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
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.
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/>. */
21 #include <sys/param.h>
27 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
30 /* To create an empty CTF container, we just declare a zeroed header and call
31 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new container r/w
32 and initialize the dynamic members. We set dtvstrlen to 1 to reserve the
33 first byte of the string table for a \0 byte, and we start assigning type
34 IDs at 1 because type ID 0 is used as a sentinel and a not-found
38 ctf_create (int *errp)
40 static const ctf_header_t hdr = { .cth_preamble = { CTF_MAGIC, CTF_VERSION, 0 } };
42 ctf_dynhash_t *dthash;
43 ctf_dynhash_t *dvhash;
44 ctf_dynhash_t *dtbyname;
49 dthash = ctf_dynhash_create (ctf_hash_integer, ctf_hash_eq_integer,
53 ctf_set_open_errno (errp, EAGAIN);
57 dvhash = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
61 ctf_set_open_errno (errp, EAGAIN);
65 dtbyname = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
69 ctf_set_open_errno (errp, EAGAIN);
73 cts.cts_name = _CTF_SECTION;
75 cts.cts_size = sizeof (hdr);
78 if ((fp = ctf_bufopen (&cts, NULL, NULL, errp)) == NULL)
81 fp->ctf_flags |= LCTF_RDWR;
82 fp->ctf_dtbyname = dtbyname;
83 fp->ctf_dthash = dthash;
84 fp->ctf_dvhash = dvhash;
85 fp->ctf_dtvstrlen = 1;
88 fp->ctf_snapshots = 0;
89 fp->ctf_snapshot_lu = 0;
94 ctf_dynhash_destroy (dtbyname);
96 ctf_dynhash_destroy (dvhash);
98 ctf_dynhash_destroy (dthash);
103 static unsigned char *
104 ctf_copy_smembers (ctf_dtdef_t *dtd, uint32_t soff, unsigned char *t)
106 ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
109 for (; dmd != NULL; dmd = ctf_list_next (dmd))
114 soff += strlen (dmd->dmd_name) + 1;
119 ctm.ctm_type = (uint32_t) dmd->dmd_type;
120 ctm.ctm_offset = (uint32_t) dmd->dmd_offset;
122 memcpy (t, &ctm, sizeof (ctm));
129 static unsigned char *
130 ctf_copy_lmembers (ctf_dtdef_t *dtd, uint32_t soff, unsigned char *t)
132 ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
135 for (; dmd != NULL; dmd = ctf_list_next (dmd))
139 ctlm.ctlm_name = soff;
140 soff += strlen (dmd->dmd_name) + 1;
145 ctlm.ctlm_type = (uint32_t) dmd->dmd_type;
146 ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset);
147 ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset);
149 memcpy (t, &ctlm, sizeof (ctlm));
156 static unsigned char *
157 ctf_copy_emembers (ctf_dtdef_t *dtd, uint32_t soff, unsigned char *t)
159 ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
162 for (; dmd != NULL; dmd = ctf_list_next (dmd))
165 cte.cte_value = dmd->dmd_value;
166 soff += strlen (dmd->dmd_name) + 1;
167 memcpy (t, &cte, sizeof (cte));
174 static unsigned char *
175 ctf_copy_membnames (ctf_dtdef_t *dtd, unsigned char *s)
177 ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
180 for (; dmd != NULL; dmd = ctf_list_next (dmd))
182 if (dmd->dmd_name == NULL)
183 continue; /* Skip anonymous members. */
184 len = strlen (dmd->dmd_name) + 1;
185 memcpy (s, dmd->dmd_name, len);
192 /* Sort a newly-constructed static variable array. */
195 ctf_sort_var (const void *one_, const void *two_, void *strtab_)
197 const ctf_varent_t *one = one_;
198 const ctf_varent_t *two = two_;
199 const char *strtab = strtab_;
200 const char *n1 = strtab + CTF_NAME_OFFSET (one->ctv_name);
201 const char *n2 = strtab + CTF_NAME_OFFSET (two->ctv_name);
203 return (strcmp (n1, n2));
206 /* If the specified CTF container is writable and has been modified, reload this
207 container with the updated type definitions. In order to make this code and
208 the rest of libctf as simple as possible, we perform updates by taking the
209 dynamic type definitions and creating an in-memory CTF file containing the
210 definitions, and then call ctf_simple_open() on it. This not only leverages
211 ctf_simple_open(), but also avoids having to bifurcate the rest of the library
212 code with different lookup paths for static and dynamic type definitions. We
213 are therefore optimizing greatly for lookup over update, which we assume will
214 be an uncommon operation. We perform one extra trick here for the benefit of
215 callers and to keep our code simple: ctf_simple_open() will return a new
216 ctf_file_t, but we want to keep the fp constant for the caller, so after
217 ctf_simple_open() returns, we use memcpy to swap the interior of the old and
218 new ctf_file_t's, and then free the old. */
220 ctf_update (ctf_file_t *fp)
222 ctf_file_t ofp, *nfp;
226 ctf_varent_t *dvarents;
228 unsigned char *s, *s0, *t;
230 size_t buf_size, type_size, nvars;
234 if (!(fp->ctf_flags & LCTF_RDWR))
235 return (ctf_set_errno (fp, ECTF_RDONLY));
237 /* Update required? */
238 if (!(fp->ctf_flags & LCTF_DIRTY))
241 /* Fill in an initial CTF header. We will leave the label, object,
242 and function sections empty and only output a header, type section,
243 and string table. The type section begins at a 4-byte aligned
244 boundary past the CTF header itself (at relative offset zero). */
246 memset (&hdr, 0, sizeof (hdr));
247 hdr.cth_magic = CTF_MAGIC;
248 hdr.cth_version = CTF_VERSION;
250 if (fp->ctf_flags & LCTF_CHILD)
251 hdr.cth_parname = 1; /* parname added just below. */
253 /* Iterate through the dynamic type definition list and compute the
254 size of the CTF type section we will need to generate. */
256 for (type_size = 0, dtd = ctf_list_next (&fp->ctf_dtdefs);
257 dtd != NULL; dtd = ctf_list_next (dtd))
259 uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
260 uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
262 if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
263 type_size += sizeof (ctf_stype_t);
265 type_size += sizeof (ctf_type_t);
271 type_size += sizeof (uint32_t);
274 type_size += sizeof (ctf_array_t);
277 type_size += sizeof (ctf_slice_t);
280 type_size += sizeof (uint32_t) * (vlen + (vlen & 1));
284 if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
285 type_size += sizeof (ctf_member_t) * vlen;
287 type_size += sizeof (ctf_lmember_t) * vlen;
290 type_size += sizeof (ctf_enum_t) * vlen;
295 /* Computing the number of entries in the CTF variable section is much
298 for (nvars = 0, dvd = ctf_list_next (&fp->ctf_dvdefs);
299 dvd != NULL; dvd = ctf_list_next (dvd), nvars++);
301 /* Fill in the string table and type offset and size, compute the size
302 of the entire CTF buffer we need, and then allocate a new buffer and
303 memcpy the finished header to the start of the buffer. */
305 hdr.cth_typeoff = hdr.cth_varoff + (nvars * sizeof (ctf_varent_t));
306 hdr.cth_stroff = hdr.cth_typeoff + type_size;
307 hdr.cth_strlen = fp->ctf_dtvstrlen;
308 if (fp->ctf_parname != NULL)
309 hdr.cth_strlen += strlen (fp->ctf_parname) + 1;
311 buf_size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
313 if ((buf = ctf_data_alloc (buf_size)) == NULL)
314 return (ctf_set_errno (fp, EAGAIN));
316 memcpy (buf, &hdr, sizeof (ctf_header_t));
317 t = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_varoff;
318 s = s0 = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff;
323 if (fp->ctf_parname != NULL)
325 memcpy (s, fp->ctf_parname, strlen (fp->ctf_parname) + 1);
326 s += strlen (fp->ctf_parname) + 1;
329 /* Work over the variable list, translating everything into
330 ctf_varent_t's and filling out the string table, then sort the buffer
331 of ctf_varent_t's. */
333 dvarents = (ctf_varent_t *) t;
334 for (i = 0, dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
335 dvd = ctf_list_next (dvd), i++)
337 ctf_varent_t *var = &dvarents[i];
338 size_t len = strlen (dvd->dvd_name) + 1;
340 var->ctv_name = (uint32_t) (s - s0);
341 var->ctv_type = dvd->dvd_type;
342 memcpy (s, dvd->dvd_name, len);
347 qsort_r (dvarents, nvars, sizeof (ctf_varent_t), ctf_sort_var, s0);
348 t += sizeof (ctf_varent_t) * nvars;
350 assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_typeoff);
352 /* We now take a final lap through the dynamic type definition list and
353 copy the appropriate type records and strings to the output buffer. */
355 for (dtd = ctf_list_next (&fp->ctf_dtdefs);
356 dtd != NULL; dtd = ctf_list_next (dtd))
359 uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
360 uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
366 if (dtd->dtd_name != NULL)
368 dtd->dtd_data.ctt_name = (uint32_t) (s - s0);
369 len = strlen (dtd->dtd_name) + 1;
370 memcpy (s, dtd->dtd_name, len);
374 dtd->dtd_data.ctt_name = 0;
376 if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
377 len = sizeof (ctf_stype_t);
379 len = sizeof (ctf_type_t);
381 memcpy (t, &dtd->dtd_data, len);
388 if (kind == CTF_K_INTEGER)
390 encoding = CTF_INT_DATA (dtd->dtd_u.dtu_enc.cte_format,
391 dtd->dtd_u.dtu_enc.cte_offset,
392 dtd->dtd_u.dtu_enc.cte_bits);
396 encoding = CTF_FP_DATA (dtd->dtd_u.dtu_enc.cte_format,
397 dtd->dtd_u.dtu_enc.cte_offset,
398 dtd->dtd_u.dtu_enc.cte_bits);
400 memcpy (t, &encoding, sizeof (encoding));
401 t += sizeof (encoding);
405 memcpy (t, &dtd->dtd_u.dtu_slice, sizeof (struct ctf_slice));
406 t += sizeof (struct ctf_slice);
410 cta.cta_contents = (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents;
411 cta.cta_index = (uint32_t) dtd->dtd_u.dtu_arr.ctr_index;
412 cta.cta_nelems = dtd->dtd_u.dtu_arr.ctr_nelems;
413 memcpy (t, &cta, sizeof (cta));
419 uint32_t *argv = (uint32_t *) (uintptr_t) t;
422 for (argc = 0; argc < vlen; argc++)
423 *argv++ = (uint32_t) dtd->dtd_u.dtu_argv[argc];
426 *argv++ = 0; /* Pad to 4-byte boundary. */
428 t = (unsigned char *) argv;
434 if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
435 t = ctf_copy_smembers (dtd, (uint32_t) (s - s0), t);
437 t = ctf_copy_lmembers (dtd, (uint32_t) (s - s0), t);
438 s = ctf_copy_membnames (dtd, s);
442 t = ctf_copy_emembers (dtd, (uint32_t) (s - s0), t);
443 s = ctf_copy_membnames (dtd, s);
447 assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff);
449 /* Finally, we are ready to ctf_simple_open() the new container. If this
450 is successful, we then switch nfp and fp and free the old container. */
452 ctf_data_protect (buf, buf_size);
454 if ((nfp = ctf_simple_open (buf, buf_size, NULL, 0, 0, NULL, 0, &err)) == NULL)
456 ctf_data_free (buf, buf_size);
457 return (ctf_set_errno (fp, err));
460 (void) ctf_setmodel (nfp, ctf_getmodel (fp));
461 (void) ctf_import (nfp, fp->ctf_parent);
463 nfp->ctf_refcnt = fp->ctf_refcnt;
464 nfp->ctf_flags |= fp->ctf_flags & ~LCTF_DIRTY;
465 nfp->ctf_data.cts_data = NULL; /* Force ctf_data_free() on close. */
466 nfp->ctf_dthash = fp->ctf_dthash;
467 nfp->ctf_dtdefs = fp->ctf_dtdefs;
468 nfp->ctf_dtbyname = fp->ctf_dtbyname;
469 nfp->ctf_dvhash = fp->ctf_dvhash;
470 nfp->ctf_dvdefs = fp->ctf_dvdefs;
471 nfp->ctf_dtvstrlen = fp->ctf_dtvstrlen;
472 nfp->ctf_dtnextid = fp->ctf_dtnextid;
473 nfp->ctf_dtoldid = fp->ctf_dtnextid - 1;
474 nfp->ctf_snapshots = fp->ctf_snapshots + 1;
475 nfp->ctf_specific = fp->ctf_specific;
477 nfp->ctf_snapshot_lu = fp->ctf_snapshots;
479 fp->ctf_dtbyname = NULL;
480 fp->ctf_dthash = NULL;
481 memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
483 fp->ctf_dvhash = NULL;
484 memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
486 memcpy (&ofp, fp, sizeof (ctf_file_t));
487 memcpy (fp, nfp, sizeof (ctf_file_t));
488 memcpy (nfp, &ofp, sizeof (ctf_file_t));
490 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
491 array of type name prefixes and the corresponding ctf_dynhash to use.
492 NOTE: This code must be kept in sync with the code in ctf_bufopen(). */
494 fp->ctf_lookups[0].ctl_hash = fp->ctf_structs;
495 fp->ctf_lookups[1].ctl_hash = fp->ctf_unions;
496 fp->ctf_lookups[2].ctl_hash = fp->ctf_enums;
497 fp->ctf_lookups[3].ctl_hash = fp->ctf_names;
499 nfp->ctf_refcnt = 1; /* Force nfp to be freed. */
500 ctf_file_close (nfp);
506 ctf_prefixed_name (int kind, const char *name)
513 prefixed = ctf_strdup ("struct ");
516 prefixed = ctf_strdup ("union ");
519 prefixed = ctf_strdup ("enum ");
522 prefixed = ctf_strdup ("");
525 prefixed = ctf_str_append (prefixed, name);
530 ctf_dtd_insert (ctf_file_t *fp, ctf_dtdef_t *dtd)
532 ctf_dynhash_insert (fp->ctf_dthash, (void *) dtd->dtd_type, dtd);
533 ctf_list_append (&fp->ctf_dtdefs, dtd);
536 int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
537 ctf_dynhash_insert (fp->ctf_dtbyname, ctf_prefixed_name (kind,
544 ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
546 ctf_dmdef_t *dmd, *nmd;
547 int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
549 ctf_dynhash_remove (fp->ctf_dthash, (void *) dtd->dtd_type);
556 for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
557 dmd != NULL; dmd = nmd)
559 if (dmd->dmd_name != NULL)
561 fp->ctf_dtvstrlen -= strlen (dmd->dmd_name) + 1;
562 ctf_free (dmd->dmd_name);
564 nmd = ctf_list_next (dmd);
569 ctf_free (dtd->dtd_u.dtu_argv);
577 name = ctf_prefixed_name (kind, dtd->dtd_name);
578 ctf_dynhash_remove (fp->ctf_dtbyname, name);
581 fp->ctf_dtvstrlen -= strlen (dtd->dtd_name) + 1;
582 ctf_free (dtd->dtd_name);
585 ctf_list_delete (&fp->ctf_dtdefs, dtd);
590 ctf_dtd_lookup (const ctf_file_t *fp, ctf_id_t type)
592 return (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dthash, (void *) type);
596 ctf_dtd_lookup_type_by_name (ctf_file_t *fp, int kind, const char *name)
599 char *decorated = ctf_prefixed_name (kind, name);
601 dtd = (ctf_dtdef_t *) ctf_dynhash_lookup (fp->ctf_dtbyname, decorated);
605 return dtd->dtd_type;
611 ctf_dynamic_type (const ctf_file_t *fp, ctf_id_t id)
615 if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, id))
618 idx = LCTF_TYPE_TO_INDEX(fp, id);
620 if (((unsigned long) idx > fp->ctf_typemax) &&
621 ((unsigned long) idx < fp->ctf_dtnextid))
622 return ctf_dtd_lookup (fp, id);
627 ctf_dvd_insert (ctf_file_t *fp, ctf_dvdef_t *dvd)
629 ctf_dynhash_insert (fp->ctf_dvhash, dvd->dvd_name, dvd);
630 ctf_list_append (&fp->ctf_dvdefs, dvd);
634 ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
636 ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name);
638 fp->ctf_dtvstrlen -= strlen (dvd->dvd_name) + 1;
639 ctf_free (dvd->dvd_name);
641 ctf_list_delete (&fp->ctf_dvdefs, dvd);
646 ctf_dvd_lookup (const ctf_file_t *fp, const char *name)
648 return (ctf_dvdef_t *) ctf_dynhash_lookup (fp->ctf_dvhash, name);
651 /* Discard all of the dynamic type definitions and variable definitions that
652 have been added to the container since the last call to ctf_update(). We
653 locate such types by scanning the dtd list and deleting elements that have
654 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
655 by scanning the variable list and deleting elements that have update IDs
656 equal to the current value of the last-update snapshot count (indicating that
657 they were added after the most recent call to ctf_update()). */
659 ctf_discard (ctf_file_t *fp)
661 ctf_snapshot_id_t last_update =
663 fp->ctf_snapshot_lu + 1 };
665 /* Update required? */
666 if (!(fp->ctf_flags & LCTF_DIRTY))
669 return (ctf_rollback (fp, last_update));
673 ctf_snapshot (ctf_file_t *fp)
675 ctf_snapshot_id_t snapid;
676 snapid.dtd_id = fp->ctf_dtnextid - 1;
677 snapid.snapshot_id = fp->ctf_snapshots++;
681 /* Like ctf_discard(), only discards everything after a particular ID. */
683 ctf_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
685 ctf_dtdef_t *dtd, *ntd;
686 ctf_dvdef_t *dvd, *nvd;
688 if (!(fp->ctf_flags & LCTF_RDWR))
689 return (ctf_set_errno (fp, ECTF_RDONLY));
691 if (fp->ctf_dtoldid > id.dtd_id)
692 return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
694 if (fp->ctf_snapshot_lu >= id.snapshot_id)
695 return (ctf_set_errno (fp, ECTF_OVERROLLBACK));
697 for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
699 ntd = ctf_list_next (dtd);
701 if (LCTF_TYPE_TO_INDEX (fp, dtd->dtd_type) <= id.dtd_id)
704 ctf_dtd_delete (fp, dtd);
707 for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
709 nvd = ctf_list_next (dvd);
711 if (dvd->dvd_snapshots <= id.snapshot_id)
714 ctf_dvd_delete (fp, dvd);
717 fp->ctf_dtnextid = id.dtd_id + 1;
718 fp->ctf_snapshots = id.snapshot_id;
720 if (fp->ctf_snapshots == fp->ctf_snapshot_lu)
721 fp->ctf_flags &= ~LCTF_DIRTY;
727 ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name,
734 if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
735 return (ctf_set_errno (fp, EINVAL));
737 if (!(fp->ctf_flags & LCTF_RDWR))
738 return (ctf_set_errno (fp, ECTF_RDONLY));
740 if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_dtnextid, 1) > CTF_MAX_TYPE)
741 return (ctf_set_errno (fp, ECTF_FULL));
743 if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_dtnextid, 1) == CTF_MAX_PTYPE)
744 return (ctf_set_errno (fp, ECTF_FULL));
746 if ((dtd = ctf_alloc (sizeof (ctf_dtdef_t))) == NULL)
747 return (ctf_set_errno (fp, EAGAIN));
749 if (name != NULL && (s = ctf_strdup (name)) == NULL)
752 return (ctf_set_errno (fp, EAGAIN));
755 type = fp->ctf_dtnextid++;
756 type = LCTF_INDEX_TO_TYPE (fp, type, (fp->ctf_flags & LCTF_CHILD));
758 memset (dtd, 0, sizeof (ctf_dtdef_t));
760 dtd->dtd_type = type;
763 fp->ctf_dtvstrlen += strlen (s) + 1;
765 ctf_dtd_insert (fp, dtd);
766 fp->ctf_flags |= LCTF_DIRTY;
772 /* When encoding integer sizes, we want to convert a byte count in the range
773 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
774 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
790 ctf_add_encoded (ctf_file_t *fp, uint32_t flag,
791 const char *name, const ctf_encoding_t *ep, uint32_t kind)
797 return (ctf_set_errno (fp, EINVAL));
799 if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
800 return CTF_ERR; /* errno is set for us. */
802 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
803 dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, NBBY) / NBBY);
804 dtd->dtd_u.dtu_enc = *ep;
810 ctf_add_reftype (ctf_file_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
814 ctf_file_t *tmp = fp;
816 if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
817 return (ctf_set_errno (fp, EINVAL));
819 if (ctf_lookup_by_id (&tmp, ref) == NULL)
820 return CTF_ERR; /* errno is set for us. */
822 if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
823 return CTF_ERR; /* errno is set for us. */
825 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
826 dtd->dtd_data.ctt_type = (uint32_t) ref;
832 ctf_add_slice (ctf_file_t *fp, uint32_t flag, ctf_id_t ref,
833 const ctf_encoding_t *ep)
838 const ctf_type_t *tp;
839 ctf_file_t *tmp = fp;
842 return (ctf_set_errno (fp, EINVAL));
844 if ((ep->cte_bits > 255) || (ep->cte_offset > 255))
845 return (ctf_set_errno (fp, ECTF_SLICEOVERFLOW));
847 if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
848 return (ctf_set_errno (fp, EINVAL));
850 if ((tp = ctf_lookup_by_id (&tmp, ref)) == NULL)
851 return CTF_ERR; /* errno is set for us. */
853 kind = ctf_type_kind_unsliced (tmp, ref);
854 if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) &&
855 (kind != CTF_K_ENUM))
856 return (ctf_set_errno (fp, ECTF_NOTINTFP));
858 if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
859 return CTF_ERR; /* errno is set for us. */
861 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
862 dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, NBBY) / NBBY);
863 dtd->dtd_u.dtu_slice.cts_type = ref;
864 dtd->dtd_u.dtu_slice.cts_bits = ep->cte_bits;
865 dtd->dtd_u.dtu_slice.cts_offset = ep->cte_offset;
871 ctf_add_integer (ctf_file_t *fp, uint32_t flag,
872 const char *name, const ctf_encoding_t *ep)
874 return (ctf_add_encoded (fp, flag, name, ep, CTF_K_INTEGER));
878 ctf_add_float (ctf_file_t *fp, uint32_t flag,
879 const char *name, const ctf_encoding_t *ep)
881 return (ctf_add_encoded (fp, flag, name, ep, CTF_K_FLOAT));
885 ctf_add_pointer (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
887 return (ctf_add_reftype (fp, flag, ref, CTF_K_POINTER));
891 ctf_add_array (ctf_file_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
895 ctf_file_t *tmp = fp;
898 return (ctf_set_errno (fp, EINVAL));
900 if (ctf_lookup_by_id (&tmp, arp->ctr_contents) == NULL)
901 return CTF_ERR; /* errno is set for us. */
904 if (ctf_lookup_by_id (&tmp, arp->ctr_index) == NULL)
905 return CTF_ERR; /* errno is set for us. */
907 if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
908 return CTF_ERR; /* errno is set for us. */
910 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
911 dtd->dtd_data.ctt_size = 0;
912 dtd->dtd_u.dtu_arr = *arp;
918 ctf_set_array (ctf_file_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
920 ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
922 if (!(fp->ctf_flags & LCTF_RDWR))
923 return (ctf_set_errno (fp, ECTF_RDONLY));
926 || LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
927 return (ctf_set_errno (fp, ECTF_BADID));
929 fp->ctf_flags |= LCTF_DIRTY;
930 dtd->dtd_u.dtu_arr = *arp;
936 ctf_add_function (ctf_file_t *fp, uint32_t flag,
937 const ctf_funcinfo_t *ctc, const ctf_id_t *argv)
942 ctf_id_t *vdat = NULL;
943 ctf_file_t *tmp = fp;
946 if (ctc == NULL || (ctc->ctc_flags & ~CTF_FUNC_VARARG) != 0
947 || (ctc->ctc_argc != 0 && argv == NULL))
948 return (ctf_set_errno (fp, EINVAL));
950 vlen = ctc->ctc_argc;
951 if (ctc->ctc_flags & CTF_FUNC_VARARG)
952 vlen++; /* Add trailing zero to indicate varargs (see below). */
954 if (ctf_lookup_by_id (&tmp, ctc->ctc_return) == NULL)
955 return CTF_ERR; /* errno is set for us. */
957 for (i = 0; i < ctc->ctc_argc; i++)
960 if (ctf_lookup_by_id (&tmp, argv[i]) == NULL)
961 return CTF_ERR; /* errno is set for us. */
964 if (vlen > CTF_MAX_VLEN)
965 return (ctf_set_errno (fp, EOVERFLOW));
967 if (vlen != 0 && (vdat = ctf_alloc (sizeof (ctf_id_t) * vlen)) == NULL)
968 return (ctf_set_errno (fp, EAGAIN));
970 if ((type = ctf_add_generic (fp, flag, NULL, &dtd)) == CTF_ERR)
973 return CTF_ERR; /* errno is set for us. */
976 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
977 dtd->dtd_data.ctt_type = (uint32_t) ctc->ctc_return;
979 memcpy (vdat, argv, sizeof (ctf_id_t) * ctc->ctc_argc);
980 if (ctc->ctc_flags & CTF_FUNC_VARARG)
981 vdat[vlen - 1] = 0; /* Add trailing zero to indicate varargs. */
982 dtd->dtd_u.dtu_argv = vdat;
988 ctf_add_struct_sized (ctf_file_t *fp, uint32_t flag, const char *name,
991 ctf_hash_t *hp = fp->ctf_structs;
995 /* Promote forwards to structs. */
999 type = ctf_hash_lookup_type (hp, fp, name);
1001 type = ctf_dtd_lookup_type_by_name (fp, CTF_K_STRUCT, name);
1004 if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1005 dtd = ctf_dtd_lookup (fp, type);
1006 else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
1007 return CTF_ERR; /* errno is set for us. */
1009 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
1011 if (size > CTF_MAX_SIZE)
1013 dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1014 dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1015 dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1018 dtd->dtd_data.ctt_size = (uint32_t) size;
1024 ctf_add_struct (ctf_file_t *fp, uint32_t flag, const char *name)
1026 return (ctf_add_struct_sized (fp, flag, name, 0));
1030 ctf_add_union_sized (ctf_file_t *fp, uint32_t flag, const char *name,
1033 ctf_hash_t *hp = fp->ctf_unions;
1037 /* Promote forwards to unions. */
1040 type = ctf_hash_lookup_type (hp, fp, name);
1042 type = ctf_dtd_lookup_type_by_name (fp, CTF_K_UNION, name);
1045 if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1046 dtd = ctf_dtd_lookup (fp, type);
1047 else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
1048 return CTF_ERR; /* errno is set for us */
1050 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
1052 if (size > CTF_MAX_SIZE)
1054 dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1055 dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1056 dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1059 dtd->dtd_data.ctt_size = (uint32_t) size;
1065 ctf_add_union (ctf_file_t *fp, uint32_t flag, const char *name)
1067 return (ctf_add_union_sized (fp, flag, name, 0));
1071 ctf_add_enum (ctf_file_t *fp, uint32_t flag, const char *name)
1073 ctf_hash_t *hp = fp->ctf_enums;
1077 /* Promote forwards to enums. */
1080 type = ctf_hash_lookup_type (hp, fp, name);
1082 type = ctf_dtd_lookup_type_by_name (fp, CTF_K_ENUM, name);
1085 if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
1086 dtd = ctf_dtd_lookup (fp, type);
1087 else if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
1088 return CTF_ERR; /* errno is set for us. */
1090 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
1091 dtd->dtd_data.ctt_size = fp->ctf_dmodel->ctd_int;
1097 ctf_add_enum_encoded (ctf_file_t *fp, uint32_t flag, const char *name,
1098 const ctf_encoding_t *ep)
1100 ctf_hash_t *hp = fp->ctf_enums;
1103 /* First, create the enum if need be, using most of the same machinery as
1104 ctf_add_enum(), to ensure that we do not allow things past that are not
1105 enums or forwards to them. (This includes other slices: you cannot slice a
1106 slice, which would be a useless thing to do anyway.) */
1110 type = ctf_hash_lookup_type (hp, fp, name);
1112 type = ctf_dtd_lookup_type_by_name (fp, CTF_K_ENUM, name);
1117 if ((ctf_type_kind (fp, type) != CTF_K_FORWARD) &&
1118 (ctf_type_kind_unsliced (fp, type) != CTF_K_ENUM))
1119 return (ctf_set_errno (fp, ECTF_NOTINTFP));
1121 else if ((type = ctf_add_enum (fp, flag, name)) == CTF_ERR)
1122 return CTF_ERR; /* errno is set for us. */
1124 /* Now attach a suitable slice to it. */
1126 return ctf_add_slice (fp, flag, type, ep);
1130 ctf_add_forward (ctf_file_t *fp, uint32_t flag, const char *name,
1140 hp = fp->ctf_structs;
1143 hp = fp->ctf_unions;
1149 return (ctf_set_errno (fp, ECTF_NOTSUE));
1152 /* If the type is already defined or exists as a forward tag, just
1153 return the ctf_id_t of the existing definition. */
1157 if (((type = ctf_hash_lookup_type (hp, fp, name)) != 0)
1158 || (type = ctf_dtd_lookup_type_by_name (fp, kind, name)) != 0)
1162 if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
1163 return CTF_ERR; /* errno is set for us. */
1165 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
1166 dtd->dtd_data.ctt_type = kind;
1172 ctf_add_typedef (ctf_file_t *fp, uint32_t flag, const char *name,
1177 ctf_file_t *tmp = fp;
1179 if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
1180 return (ctf_set_errno (fp, EINVAL));
1182 if (ctf_lookup_by_id (&tmp, ref) == NULL)
1183 return CTF_ERR; /* errno is set for us. */
1185 if ((type = ctf_add_generic (fp, flag, name, &dtd)) == CTF_ERR)
1186 return CTF_ERR; /* errno is set for us. */
1188 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
1189 dtd->dtd_data.ctt_type = (uint32_t) ref;
1195 ctf_add_volatile (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1197 return (ctf_add_reftype (fp, flag, ref, CTF_K_VOLATILE));
1201 ctf_add_const (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1203 return (ctf_add_reftype (fp, flag, ref, CTF_K_CONST));
1207 ctf_add_restrict (ctf_file_t *fp, uint32_t flag, ctf_id_t ref)
1209 return (ctf_add_reftype (fp, flag, ref, CTF_K_RESTRICT));
1213 ctf_add_enumerator (ctf_file_t *fp, ctf_id_t enid, const char *name,
1216 ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, enid);
1219 uint32_t kind, vlen, root;
1223 return (ctf_set_errno (fp, EINVAL));
1225 if (!(fp->ctf_flags & LCTF_RDWR))
1226 return (ctf_set_errno (fp, ECTF_RDONLY));
1229 return (ctf_set_errno (fp, ECTF_BADID));
1231 kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1232 root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1233 vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1235 if (kind != CTF_K_ENUM)
1236 return (ctf_set_errno (fp, ECTF_NOTENUM));
1238 if (vlen == CTF_MAX_VLEN)
1239 return (ctf_set_errno (fp, ECTF_DTFULL));
1241 for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1242 dmd != NULL; dmd = ctf_list_next (dmd))
1244 if (strcmp (dmd->dmd_name, name) == 0)
1245 return (ctf_set_errno (fp, ECTF_DUPLICATE));
1248 if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
1249 return (ctf_set_errno (fp, EAGAIN));
1251 if ((s = ctf_strdup (name)) == NULL)
1254 return (ctf_set_errno (fp, EAGAIN));
1258 dmd->dmd_type = CTF_ERR;
1259 dmd->dmd_offset = 0;
1260 dmd->dmd_value = value;
1262 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1263 ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1265 fp->ctf_dtvstrlen += strlen (s) + 1;
1266 fp->ctf_flags |= LCTF_DIRTY;
1272 ctf_add_member_offset (ctf_file_t *fp, ctf_id_t souid, const char *name,
1273 ctf_id_t type, unsigned long bit_offset)
1275 ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, souid);
1278 ssize_t msize, malign, ssize;
1279 uint32_t kind, vlen, root;
1282 if (!(fp->ctf_flags & LCTF_RDWR))
1283 return (ctf_set_errno (fp, ECTF_RDONLY));
1286 return (ctf_set_errno (fp, ECTF_BADID));
1288 kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1289 root = LCTF_INFO_ISROOT (fp, dtd->dtd_data.ctt_info);
1290 vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
1292 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
1293 return (ctf_set_errno (fp, ECTF_NOTSOU));
1295 if (vlen == CTF_MAX_VLEN)
1296 return (ctf_set_errno (fp, ECTF_DTFULL));
1300 for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1301 dmd != NULL; dmd = ctf_list_next (dmd))
1303 if (dmd->dmd_name != NULL && strcmp (dmd->dmd_name, name) == 0)
1304 return (ctf_set_errno (fp, ECTF_DUPLICATE));
1308 if ((msize = ctf_type_size (fp, type)) < 0 ||
1309 (malign = ctf_type_align (fp, type)) < 0)
1310 return -1; /* errno is set for us. */
1312 if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
1313 return (ctf_set_errno (fp, EAGAIN));
1315 if (name != NULL && (s = ctf_strdup (name)) == NULL)
1318 return (ctf_set_errno (fp, EAGAIN));
1322 dmd->dmd_type = type;
1323 dmd->dmd_value = -1;
1325 if (kind == CTF_K_STRUCT && vlen != 0)
1327 if (bit_offset == (unsigned long) - 1)
1329 /* Natural alignment. */
1331 ctf_dmdef_t *lmd = ctf_list_prev (&dtd->dtd_u.dtu_members);
1332 ctf_id_t ltype = ctf_type_resolve (fp, lmd->dmd_type);
1333 size_t off = lmd->dmd_offset;
1335 ctf_encoding_t linfo;
1338 if (ctf_type_encoding (fp, ltype, &linfo) == 0)
1339 off += linfo.cte_bits;
1340 else if ((lsize = ctf_type_size (fp, ltype)) > 0)
1341 off += lsize * NBBY;
1343 /* Round up the offset of the end of the last member to
1344 the next byte boundary, convert 'off' to bytes, and
1345 then round it up again to the next multiple of the
1346 alignment required by the new member. Finally,
1347 convert back to bits and store the result in
1348 dmd_offset. Technically we could do more efficient
1349 packing if the new member is a bit-field, but we're
1350 the "compiler" and ANSI says we can do as we choose. */
1352 off = roundup (off, NBBY) / NBBY;
1353 off = roundup (off, MAX (malign, 1));
1354 dmd->dmd_offset = off * NBBY;
1355 ssize = off + msize;
1359 /* Specified offset in bits. */
1361 dmd->dmd_offset = bit_offset;
1362 ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1363 ssize = MAX (ssize, ((signed) bit_offset / NBBY) + msize);
1368 dmd->dmd_offset = 0;
1369 ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
1370 ssize = MAX (ssize, msize);
1373 if ((size_t) ssize > CTF_MAX_SIZE)
1375 dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1376 dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (ssize);
1377 dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (ssize);
1380 dtd->dtd_data.ctt_size = (uint32_t) ssize;
1382 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
1383 ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
1386 fp->ctf_dtvstrlen += strlen (s) + 1;
1388 fp->ctf_flags |= LCTF_DIRTY;
1393 ctf_add_member_encoded (ctf_file_t *fp, ctf_id_t souid, const char *name,
1394 ctf_id_t type, unsigned long bit_offset,
1395 const ctf_encoding_t encoding)
1397 ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
1398 int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
1401 if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) && (kind != CTF_K_ENUM))
1402 return (ctf_set_errno (fp, ECTF_NOTINTFP));
1404 if ((type = ctf_add_slice (fp, CTF_ADD_NONROOT, otype, &encoding)) == CTF_ERR)
1405 return -1; /* errno is set for us. */
1407 return ctf_add_member_offset (fp, souid, name, type, bit_offset);
1411 ctf_add_member (ctf_file_t *fp, ctf_id_t souid, const char *name,
1414 return ctf_add_member_offset (fp, souid, name, type, (unsigned long) - 1);
1418 ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
1421 ctf_file_t *tmp = fp;
1423 if (!(fp->ctf_flags & LCTF_RDWR))
1424 return (ctf_set_errno (fp, ECTF_RDONLY));
1426 if (ctf_dvd_lookup (fp, name) != NULL)
1427 return (ctf_set_errno (fp, ECTF_DUPLICATE));
1429 if (ctf_lookup_by_id (&tmp, ref) == NULL)
1430 return -1; /* errno is set for us. */
1432 if ((dvd = ctf_alloc (sizeof (ctf_dvdef_t))) == NULL)
1433 return (ctf_set_errno (fp, EAGAIN));
1435 if (name != NULL && (dvd->dvd_name = ctf_strdup (name)) == NULL)
1438 return (ctf_set_errno (fp, EAGAIN));
1440 dvd->dvd_type = ref;
1441 dvd->dvd_snapshots = fp->ctf_snapshots;
1443 ctf_dvd_insert (fp, dvd);
1445 fp->ctf_dtvstrlen += strlen (name) + 1;
1446 fp->ctf_flags |= LCTF_DIRTY;
1451 enumcmp (const char *name, int value, void *arg)
1453 ctf_bundle_t *ctb = arg;
1456 if (ctf_enum_value (ctb->ctb_file, ctb->ctb_type, name, &bvalue) < 0)
1458 ctf_dprintf ("Conflict due to member %s iteration error.\n", name);
1461 if (value != bvalue)
1463 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1471 enumadd (const char *name, int value, void *arg)
1473 ctf_bundle_t *ctb = arg;
1475 return (ctf_add_enumerator (ctb->ctb_file, ctb->ctb_type,
1480 membcmp (const char *name, ctf_id_t type _libctf_unused_, unsigned long offset,
1483 ctf_bundle_t *ctb = arg;
1486 if (ctf_member_info (ctb->ctb_file, ctb->ctb_type, name, &ctm) < 0)
1488 ctf_dprintf ("Conflict due to member %s iteration error.\n", name);
1491 if (ctm.ctm_offset != offset)
1493 ctf_dprintf ("Conflict due to member %s offset change: "
1494 "%lx versus %lx\n", name, ctm.ctm_offset, offset);
1501 membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
1503 ctf_bundle_t *ctb = arg;
1507 if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
1508 return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1510 if (name != NULL && (s = ctf_strdup (name)) == NULL)
1513 return (ctf_set_errno (ctb->ctb_file, EAGAIN));
1516 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1517 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1519 dmd->dmd_type = type;
1520 dmd->dmd_offset = offset;
1521 dmd->dmd_value = -1;
1523 ctf_list_append (&ctb->ctb_dtd->dtd_u.dtu_members, dmd);
1526 ctb->ctb_file->ctf_dtvstrlen += strlen (s) + 1;
1528 ctb->ctb_file->ctf_flags |= LCTF_DIRTY;
1532 /* The ctf_add_type routine is used to copy a type from a source CTF container
1533 to a dynamic destination container. This routine operates recursively by
1534 following the source type's links and embedded member types. If the
1535 destination container already contains a named type which has the same
1536 attributes, then we succeed and return this type but no changes occur. */
1538 ctf_add_type (ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
1540 ctf_id_t dst_type = CTF_ERR;
1541 uint32_t dst_kind = CTF_K_UNKNOWN;
1545 uint32_t kind, flag, vlen;
1547 const ctf_type_t *src_tp, *dst_tp;
1548 ctf_bundle_t src, dst;
1549 ctf_encoding_t src_en, dst_en;
1550 ctf_arinfo_t src_ar, dst_ar;
1557 if (!(dst_fp->ctf_flags & LCTF_RDWR))
1558 return (ctf_set_errno (dst_fp, ECTF_RDONLY));
1560 if ((src_tp = ctf_lookup_by_id (&src_fp, src_type)) == NULL)
1561 return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1563 name = ctf_strptr (src_fp, src_tp->ctt_name);
1564 kind = LCTF_INFO_KIND (src_fp, src_tp->ctt_info);
1565 flag = LCTF_INFO_ISROOT (src_fp, src_tp->ctt_info);
1566 vlen = LCTF_INFO_VLEN (src_fp, src_tp->ctt_info);
1571 hp = dst_fp->ctf_structs;
1574 hp = dst_fp->ctf_unions;
1577 hp = dst_fp->ctf_enums;
1580 hp = dst_fp->ctf_names;
1584 /* If the source type has a name and is a root type (visible at the
1585 top-level scope), lookup the name in the destination container and
1586 verify that it is of the same kind before we do anything else. */
1588 if ((flag & CTF_ADD_ROOT) && name[0] != '\0'
1589 && (tmp = ctf_hash_lookup_type (hp, dst_fp, name)) != 0)
1592 dst_kind = ctf_type_kind_unsliced (dst_fp, dst_type);
1595 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1596 unless dst_type is a forward declaration and src_type is a struct,
1597 union, or enum (i.e. the definition of the previous forward decl). */
1599 if (dst_type != CTF_ERR && dst_kind != kind
1600 && (dst_kind != CTF_K_FORWARD
1601 || (kind != CTF_K_ENUM && kind != CTF_K_STRUCT
1602 && kind != CTF_K_UNION)))
1604 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1605 "old (ID %lx): %i\n", name, kind, dst_type, dst_kind);
1606 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1609 /* We take special action for an integer, float, or slice since it is
1610 described not only by its name but also its encoding. For integers,
1611 bit-fields exploit this degeneracy. */
1613 if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT || kind == CTF_K_SLICE)
1615 if (ctf_type_encoding (src_fp, src_type, &src_en) != 0)
1616 return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1618 if (dst_type != CTF_ERR)
1620 ctf_file_t *fp = dst_fp;
1622 if ((dst_tp = ctf_lookup_by_id (&fp, dst_type)) == NULL)
1625 if (LCTF_INFO_ISROOT (fp, dst_tp->ctt_info) & CTF_ADD_ROOT)
1627 /* The type that we found in the hash is also root-visible. If
1628 the two types match then use the existing one; otherwise,
1629 declare a conflict. Note: slices are not certain to match
1630 even if there is no conflict: we must check the contained type
1633 if (ctf_type_encoding (dst_fp, dst_type, &dst_en) != 0)
1634 return CTF_ERR; /* errno set for us. */
1636 if (memcmp (&src_en, &dst_en, sizeof (ctf_encoding_t)) == 0)
1638 if (kind != CTF_K_SLICE)
1643 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1648 /* We found a non-root-visible type in the hash. We reset
1649 dst_type to ensure that we continue to look for a possible
1650 conflict in the pending list. */
1657 /* If the non-empty name was not found in the appropriate hash, search
1658 the list of pending dynamic definitions that are not yet committed.
1659 If a matching name and kind are found, assume this is the type that
1660 we are looking for. This is necessary to permit ctf_add_type() to
1661 operate recursively on entities such as a struct that contains a
1662 pointer member that refers to the same struct type. */
1664 if (dst_type == CTF_ERR && name[0] != '\0')
1666 for (dtd = ctf_list_prev (&dst_fp->ctf_dtdefs); dtd != NULL
1667 && LCTF_TYPE_TO_INDEX (src_fp, dtd->dtd_type) > dst_fp->ctf_dtoldid;
1668 dtd = ctf_list_prev (dtd))
1670 if (LCTF_INFO_KIND (src_fp, dtd->dtd_data.ctt_info) == kind
1671 && dtd->dtd_name != NULL && strcmp (dtd->dtd_name, name) == 0)
1673 int sroot; /* Is the src root-visible? */
1674 int droot; /* Is the dst root-visible? */
1675 int match; /* Do the encodings match? */
1677 if (kind != CTF_K_INTEGER && kind != CTF_K_FLOAT && kind != CTF_K_SLICE)
1678 return dtd->dtd_type;
1680 sroot = (flag & CTF_ADD_ROOT);
1681 droot = (LCTF_INFO_ISROOT (dst_fp,
1683 ctt_info) & CTF_ADD_ROOT);
1685 match = (memcmp (&src_en, &dtd->dtd_u.dtu_enc,
1686 sizeof (ctf_encoding_t)) == 0);
1688 /* If the types share the same encoding then return the id of the
1689 first unless one type is root-visible and the other is not; in
1690 that case the new type must get a new id if a match is never
1691 found. Note: slices are not certain to match even if there is
1692 no conflict: we must check the contained type too. */
1694 if (match && sroot == droot)
1696 if (kind != CTF_K_SLICE)
1697 return dtd->dtd_type;
1699 else if (!match && sroot && droot)
1701 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1707 src.ctb_file = src_fp;
1708 src.ctb_type = src_type;
1711 dst.ctb_file = dst_fp;
1712 dst.ctb_type = dst_type;
1715 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then
1716 we add a new type with the same properties as src_type to dst_fp.
1717 If dst_type is not CTF_ERR, then we verify that dst_type has the
1718 same attributes as src_type. We recurse for embedded references. */
1722 /* If we found a match we will have either returned it or declared a
1724 dst_type = ctf_add_integer (dst_fp, flag, name, &src_en);
1728 /* If we found a match we will have either returned it or declared a
1730 dst_type = ctf_add_float (dst_fp, flag, name, &src_en);
1734 /* We have checked for conflicting encodings: now try to add the
1736 src_type = ctf_type_reference (src_fp, src_type);
1737 dst_type = ctf_add_type (dst_fp, src_fp, src_type);
1739 if (src_type == CTF_ERR)
1740 return CTF_ERR; /* errno is set for us. */
1742 dst_type = ctf_add_slice (dst_fp, flag, src_type, &src_en);
1746 case CTF_K_VOLATILE:
1748 case CTF_K_RESTRICT:
1749 src_type = ctf_type_reference (src_fp, src_type);
1750 src_type = ctf_add_type (dst_fp, src_fp, src_type);
1752 if (src_type == CTF_ERR)
1753 return CTF_ERR; /* errno is set for us. */
1755 dst_type = ctf_add_reftype (dst_fp, flag, src_type, kind);
1759 if (ctf_array_info (src_fp, src_type, &src_ar) != 0)
1760 return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
1762 src_ar.ctr_contents =
1763 ctf_add_type (dst_fp, src_fp, src_ar.ctr_contents);
1764 src_ar.ctr_index = ctf_add_type (dst_fp, src_fp, src_ar.ctr_index);
1765 src_ar.ctr_nelems = src_ar.ctr_nelems;
1767 if (src_ar.ctr_contents == CTF_ERR || src_ar.ctr_index == CTF_ERR)
1768 return CTF_ERR; /* errno is set for us. */
1770 if (dst_type != CTF_ERR)
1772 if (ctf_array_info (dst_fp, dst_type, &dst_ar) != 0)
1773 return CTF_ERR; /* errno is set for us. */
1775 if (memcmp (&src_ar, &dst_ar, sizeof (ctf_arinfo_t)))
1777 ctf_dprintf ("Conflict for type %s against ID %lx: "
1778 "array info differs, old %lx/%lx/%x; "
1779 "new: %lx/%lx/%x\n", name, dst_type,
1780 src_ar.ctr_contents, src_ar.ctr_index,
1781 src_ar.ctr_nelems, dst_ar.ctr_contents,
1782 dst_ar.ctr_index, dst_ar.ctr_nelems);
1783 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1787 dst_type = ctf_add_array (dst_fp, flag, &src_ar);
1790 case CTF_K_FUNCTION:
1791 ctc.ctc_return = ctf_add_type (dst_fp, src_fp, src_tp->ctt_type);
1795 if (ctc.ctc_return == CTF_ERR)
1796 return CTF_ERR; /* errno is set for us. */
1798 dst_type = ctf_add_function (dst_fp, flag, &ctc, NULL);
1809 /* Technically to match a struct or union we need to check both
1810 ways (src members vs. dst, dst members vs. src) but we make
1811 this more optimal by only checking src vs. dst and comparing
1812 the total size of the structure (which we must do anyway)
1813 which covers the possibility of dst members not in src.
1814 This optimization can be defeated for unions, but is so
1815 pathological as to render it irrelevant for our purposes. */
1817 if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD)
1819 if (ctf_type_size (src_fp, src_type) !=
1820 ctf_type_size (dst_fp, dst_type))
1822 ctf_dprintf ("Conflict for type %s against ID %lx: "
1823 "union size differs, old %zi, new %zi\n",
1824 name, dst_type, ctf_type_size (src_fp, src_type),
1825 ctf_type_size (dst_fp, dst_type));
1826 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1829 if (ctf_member_iter (src_fp, src_type, membcmp, &dst))
1831 ctf_dprintf ("Conflict for type %s against ID %lx: "
1832 "members differ, see above\n", name, dst_type);
1833 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1839 /* Unlike the other cases, copying structs and unions is done
1840 manually so as to avoid repeated lookups in ctf_add_member
1841 and to ensure the exact same member offsets as in src_type. */
1843 dst_type = ctf_add_generic (dst_fp, flag, name, &dtd);
1844 if (dst_type == CTF_ERR)
1845 return CTF_ERR; /* errno is set for us. */
1847 dst.ctb_type = dst_type;
1850 if (ctf_member_iter (src_fp, src_type, membadd, &dst) != 0)
1851 errs++; /* Increment errs and fail at bottom of case. */
1853 if ((ssize = ctf_type_size (src_fp, src_type)) < 0)
1854 return CTF_ERR; /* errno is set for us. */
1856 size = (size_t) ssize;
1857 if (size > CTF_MAX_SIZE)
1859 dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
1860 dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
1861 dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
1864 dtd->dtd_data.ctt_size = (uint32_t) size;
1866 dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, vlen);
1868 /* Make a final pass through the members changing each dmd_type (a
1869 src_fp type) to an equivalent type in dst_fp. We pass through all
1870 members, leaving any that fail set to CTF_ERR. */
1871 for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1872 dmd != NULL; dmd = ctf_list_next (dmd))
1874 if ((dmd->dmd_type = ctf_add_type (dst_fp, src_fp,
1875 dmd->dmd_type)) == CTF_ERR)
1880 return CTF_ERR; /* errno is set for us. */
1885 if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD)
1887 if (ctf_enum_iter (src_fp, src_type, enumcmp, &dst)
1888 || ctf_enum_iter (dst_fp, dst_type, enumcmp, &src))
1890 ctf_dprintf ("Conflict for enum %s against ID %lx: "
1891 "members differ, see above\n", name, dst_type);
1892 return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
1897 dst_type = ctf_add_enum (dst_fp, flag, name);
1898 if ((dst.ctb_type = dst_type) == CTF_ERR
1899 || ctf_enum_iter (src_fp, src_type, enumadd, &dst))
1900 return CTF_ERR; /* errno is set for us */
1905 if (dst_type == CTF_ERR)
1907 dst_type = ctf_add_forward (dst_fp, flag,
1908 name, CTF_K_STRUCT); /* Assume STRUCT. */
1913 src_type = ctf_type_reference (src_fp, src_type);
1914 src_type = ctf_add_type (dst_fp, src_fp, src_type);
1916 if (src_type == CTF_ERR)
1917 return CTF_ERR; /* errno is set for us. */
1919 /* If dst_type is not CTF_ERR at this point, we should check if
1920 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
1921 ECTF_CONFLICT. However, this causes problems with bitness typedefs
1922 that vary based on things like if 32-bit then pid_t is int otherwise
1923 long. We therefore omit this check and assume that if the identically
1924 named typedef already exists in dst_fp, it is correct or
1927 if (dst_type == CTF_ERR)
1929 dst_type = ctf_add_typedef (dst_fp, flag, name, src_type);
1934 return (ctf_set_errno (dst_fp, ECTF_CORRUPT));
1940 /* Write the compressed CTF data stream to the specified gzFile descriptor.
1941 This is useful for saving the results of dynamic CTF containers. */
1943 ctf_gzwrite (ctf_file_t *fp, gzFile fd)
1945 const unsigned char *buf = fp->ctf_base;
1946 ssize_t resid = fp->ctf_size;
1951 if ((len = gzwrite (fd, buf, resid)) <= 0)
1952 return (ctf_set_errno (fp, errno));
1960 /* Compress the specified CTF data stream and write it to the specified file
1963 ctf_compress_write (ctf_file_t *fp, int fd)
1968 ctf_header_t *hp = &h;
1969 ssize_t header_len = sizeof (ctf_header_t);
1970 ssize_t compress_len;
1971 size_t max_compress_len = compressBound (fp->ctf_size - header_len);
1976 memcpy (hp, fp->ctf_base, header_len);
1977 hp->cth_flags |= CTF_F_COMPRESS;
1979 if ((buf = ctf_data_alloc (max_compress_len)) == NULL)
1980 return (ctf_set_errno (fp, ECTF_ZALLOC));
1982 compress_len = max_compress_len;
1983 if ((rc = compress (buf, (uLongf *) & compress_len,
1984 fp->ctf_base + header_len,
1985 fp->ctf_size - header_len)) != Z_OK)
1987 ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
1988 err = ctf_set_errno (fp, ECTF_COMPRESS);
1992 while (header_len > 0)
1994 if ((len = write (fd, hp, header_len)) < 0)
1996 err = ctf_set_errno (fp, errno);
2004 while (compress_len > 0)
2006 if ((len = write (fd, bp, compress_len)) < 0)
2008 err = ctf_set_errno (fp, errno);
2011 compress_len -= len;
2016 ctf_data_free (buf, max_compress_len);
2020 /* Write the uncompressed CTF data stream to the specified file descriptor.
2021 This is useful for saving the results of dynamic CTF containers. */
2023 ctf_write (ctf_file_t *fp, int fd)
2025 const unsigned char *buf = fp->ctf_base;
2026 ssize_t resid = fp->ctf_size;
2031 if ((len = write (fd, buf, resid)) < 0)
2032 return (ctf_set_errno (fp, errno));