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 /* Make sure the ptrtab has enough space for at least one more type.
32 We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
36 ctf_grow_ptrtab (ctf_file_t
*fp
)
38 size_t new_ptrtab_len
= fp
->ctf_ptrtab_len
;
40 /* We allocate one more ptrtab entry than we need, for the initial zero,
41 plus one because the caller will probably allocate a new type. */
43 if (fp
->ctf_ptrtab
== NULL
)
44 new_ptrtab_len
= 1024;
45 else if ((fp
->ctf_typemax
+ 2) > fp
->ctf_ptrtab_len
)
46 new_ptrtab_len
= fp
->ctf_ptrtab_len
* 1.25;
48 if (new_ptrtab_len
!= fp
->ctf_ptrtab_len
)
52 if ((new_ptrtab
= realloc (fp
->ctf_ptrtab
,
53 new_ptrtab_len
* sizeof (uint32_t))) == NULL
)
54 return (ctf_set_errno (fp
, ENOMEM
));
56 fp
->ctf_ptrtab
= new_ptrtab
;
57 memset (fp
->ctf_ptrtab
+ fp
->ctf_ptrtab_len
, 0,
58 (new_ptrtab_len
- fp
->ctf_ptrtab_len
) * sizeof (uint32_t));
59 fp
->ctf_ptrtab_len
= new_ptrtab_len
;
64 /* To create an empty CTF container, we just declare a zeroed header and call
65 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new container r/w
66 and initialize the dynamic members. We start assigning type IDs at 1 because
67 type ID 0 is used as a sentinel and a not-found indicator. */
70 ctf_create (int *errp
)
72 static const ctf_header_t hdr
= { .cth_preamble
= { CTF_MAGIC
, CTF_VERSION
, 0 } };
74 ctf_dynhash_t
*dthash
;
75 ctf_dynhash_t
*dvhash
;
76 ctf_dynhash_t
*structs
= NULL
, *unions
= NULL
, *enums
= NULL
, *names
= NULL
;
81 dthash
= ctf_dynhash_create (ctf_hash_integer
, ctf_hash_eq_integer
,
85 ctf_set_open_errno (errp
, EAGAIN
);
89 dvhash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
93 ctf_set_open_errno (errp
, EAGAIN
);
97 structs
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
99 unions
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
101 enums
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
103 names
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
105 if (!structs
|| !unions
|| !enums
|| !names
)
107 ctf_set_open_errno (errp
, EAGAIN
);
111 cts
.cts_name
= _CTF_SECTION
;
113 cts
.cts_size
= sizeof (hdr
);
116 if ((fp
= ctf_bufopen_internal (&cts
, NULL
, NULL
, NULL
, 1, errp
)) == NULL
)
119 fp
->ctf_structs
.ctn_writable
= structs
;
120 fp
->ctf_unions
.ctn_writable
= unions
;
121 fp
->ctf_enums
.ctn_writable
= enums
;
122 fp
->ctf_names
.ctn_writable
= names
;
123 fp
->ctf_dthash
= dthash
;
124 fp
->ctf_dvhash
= dvhash
;
126 fp
->ctf_snapshots
= 1;
127 fp
->ctf_snapshot_lu
= 0;
129 ctf_set_ctl_hashes (fp
);
130 ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
131 if (ctf_grow_ptrtab (fp
) < 0)
133 ctf_set_open_errno (errp
, ctf_errno (fp
));
141 ctf_dynhash_destroy (structs
);
142 ctf_dynhash_destroy (unions
);
143 ctf_dynhash_destroy (enums
);
144 ctf_dynhash_destroy (names
);
145 ctf_dynhash_destroy (dvhash
);
147 ctf_dynhash_destroy (dthash
);
152 static unsigned char *
153 ctf_copy_smembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
155 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
158 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
160 ctf_member_t
*copied
;
163 ctm
.ctm_type
= (uint32_t) dmd
->dmd_type
;
164 ctm
.ctm_offset
= (uint32_t) dmd
->dmd_offset
;
166 memcpy (t
, &ctm
, sizeof (ctm
));
167 copied
= (ctf_member_t
*) t
;
169 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctm_name
);
177 static unsigned char *
178 ctf_copy_lmembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
180 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
183 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
185 ctf_lmember_t
*copied
;
188 ctlm
.ctlm_type
= (uint32_t) dmd
->dmd_type
;
189 ctlm
.ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (dmd
->dmd_offset
);
190 ctlm
.ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (dmd
->dmd_offset
);
192 memcpy (t
, &ctlm
, sizeof (ctlm
));
193 copied
= (ctf_lmember_t
*) t
;
195 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctlm_name
);
203 static unsigned char *
204 ctf_copy_emembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
206 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
209 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
213 cte
.cte_value
= dmd
->dmd_value
;
214 memcpy (t
, &cte
, sizeof (cte
));
215 copied
= (ctf_enum_t
*) t
;
216 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->cte_name
);
223 /* Sort a newly-constructed static variable array. */
225 typedef struct ctf_sort_var_arg_cb
229 } ctf_sort_var_arg_cb_t
;
232 ctf_sort_var (const void *one_
, const void *two_
, void *arg_
)
234 const ctf_varent_t
*one
= one_
;
235 const ctf_varent_t
*two
= two_
;
236 ctf_sort_var_arg_cb_t
*arg
= arg_
;
238 return (strcmp (ctf_strraw_explicit (arg
->fp
, one
->ctv_name
, arg
->strtab
),
239 ctf_strraw_explicit (arg
->fp
, two
->ctv_name
, arg
->strtab
)));
242 /* Compatibility: just update the threshold for ctf_discard. */
244 ctf_update (ctf_file_t
*fp
)
246 if (!(fp
->ctf_flags
& LCTF_RDWR
))
247 return (ctf_set_errno (fp
, ECTF_RDONLY
));
249 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
253 /* If the specified CTF container is writable and has been modified, reload this
254 container with the updated type definitions, ready for serialization. In
255 order to make this code and the rest of libctf as simple as possible, we
256 perform updates by taking the dynamic type definitions and creating an
257 in-memory CTF file containing the definitions, and then call
258 ctf_simple_open_internal() on it. We perform one extra trick here for the
259 benefit of callers and to keep our code simple: ctf_simple_open_internal()
260 will return a new ctf_file_t, but we want to keep the fp constant for the
261 caller, so after ctf_simple_open_internal() returns, we use memcpy to swap
262 the interior of the old and new ctf_file_t's, and then free the old. */
264 ctf_serialize (ctf_file_t
*fp
)
266 ctf_file_t ofp
, *nfp
;
267 ctf_header_t hdr
, *hdrp
;
270 ctf_varent_t
*dvarents
;
271 ctf_strs_writable_t strtab
;
275 size_t buf_size
, type_size
, nvars
;
276 unsigned char *buf
, *newbuf
;
279 if (!(fp
->ctf_flags
& LCTF_RDWR
))
280 return (ctf_set_errno (fp
, ECTF_RDONLY
));
282 /* Update required? */
283 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
286 /* Fill in an initial CTF header. We will leave the label, object,
287 and function sections empty and only output a header, type section,
288 and string table. The type section begins at a 4-byte aligned
289 boundary past the CTF header itself (at relative offset zero). */
291 memset (&hdr
, 0, sizeof (hdr
));
292 hdr
.cth_magic
= CTF_MAGIC
;
293 hdr
.cth_version
= CTF_VERSION
;
295 /* Iterate through the dynamic type definition list and compute the
296 size of the CTF type section we will need to generate. */
298 for (type_size
= 0, dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
299 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
301 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
302 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
304 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
305 type_size
+= sizeof (ctf_stype_t
);
307 type_size
+= sizeof (ctf_type_t
);
313 type_size
+= sizeof (uint32_t);
316 type_size
+= sizeof (ctf_array_t
);
319 type_size
+= sizeof (ctf_slice_t
);
322 type_size
+= sizeof (uint32_t) * (vlen
+ (vlen
& 1));
326 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
327 type_size
+= sizeof (ctf_member_t
) * vlen
;
329 type_size
+= sizeof (ctf_lmember_t
) * vlen
;
332 type_size
+= sizeof (ctf_enum_t
) * vlen
;
337 /* Computing the number of entries in the CTF variable section is much
340 for (nvars
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
);
341 dvd
!= NULL
; dvd
= ctf_list_next (dvd
), nvars
++);
343 /* Compute the size of the CTF buffer we need, sans only the string table,
344 then allocate a new buffer and memcpy the finished header to the start of
345 the buffer. (We will adjust this later with strtab length info.) */
347 hdr
.cth_typeoff
= hdr
.cth_varoff
+ (nvars
* sizeof (ctf_varent_t
));
348 hdr
.cth_stroff
= hdr
.cth_typeoff
+ type_size
;
351 buf_size
= sizeof (ctf_header_t
) + hdr
.cth_stroff
+ hdr
.cth_strlen
;
353 if ((buf
= malloc (buf_size
)) == NULL
)
354 return (ctf_set_errno (fp
, EAGAIN
));
356 memcpy (buf
, &hdr
, sizeof (ctf_header_t
));
357 t
= (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_varoff
;
359 hdrp
= (ctf_header_t
*) buf
;
360 if ((fp
->ctf_flags
& LCTF_CHILD
) && (fp
->ctf_parname
!= NULL
))
361 ctf_str_add_ref (fp
, fp
->ctf_parname
, &hdrp
->cth_parname
);
362 if (fp
->ctf_cuname
!= NULL
)
363 ctf_str_add_ref (fp
, fp
->ctf_cuname
, &hdrp
->cth_cuname
);
365 /* Work over the variable list, translating everything into ctf_varent_t's and
366 prepping the string table. */
368 dvarents
= (ctf_varent_t
*) t
;
369 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
370 dvd
= ctf_list_next (dvd
), i
++)
372 ctf_varent_t
*var
= &dvarents
[i
];
374 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
375 var
->ctv_type
= dvd
->dvd_type
;
379 t
+= sizeof (ctf_varent_t
) * nvars
;
381 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
383 /* We now take a final lap through the dynamic type definition list and copy
384 the appropriate type records to the output buffer, noting down the
387 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
388 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
390 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
391 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
399 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
400 len
= sizeof (ctf_stype_t
);
402 len
= sizeof (ctf_type_t
);
404 memcpy (t
, &dtd
->dtd_data
, len
);
405 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
407 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
408 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
415 if (kind
== CTF_K_INTEGER
)
417 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
418 dtd
->dtd_u
.dtu_enc
.cte_offset
,
419 dtd
->dtd_u
.dtu_enc
.cte_bits
);
423 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
424 dtd
->dtd_u
.dtu_enc
.cte_offset
,
425 dtd
->dtd_u
.dtu_enc
.cte_bits
);
427 memcpy (t
, &encoding
, sizeof (encoding
));
428 t
+= sizeof (encoding
);
432 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
433 t
+= sizeof (struct ctf_slice
);
437 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
438 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
439 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
440 memcpy (t
, &cta
, sizeof (cta
));
446 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
449 for (argc
= 0; argc
< vlen
; argc
++)
450 *argv
++ = (uint32_t) dtd
->dtd_u
.dtu_argv
[argc
];
453 *argv
++ = 0; /* Pad to 4-byte boundary. */
455 t
= (unsigned char *) argv
;
461 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
462 t
= ctf_copy_smembers (fp
, dtd
, t
);
464 t
= ctf_copy_lmembers (fp
, dtd
, t
);
468 t
= ctf_copy_emembers (fp
, dtd
, t
);
472 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
474 /* Construct the final string table and fill out all the string refs with the
475 final offsets. Then purge the refs list, because we're about to move this
476 strtab onto the end of the buf, invalidating all the offsets. */
477 strtab
= ctf_str_write_strtab (fp
);
478 ctf_str_purge_refs (fp
);
480 if (strtab
.cts_strs
== NULL
)
483 return (ctf_set_errno (fp
, EAGAIN
));
486 /* Now the string table is constructed, we can sort the buffer of
488 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
489 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
492 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
495 ctf_free (strtab
.cts_strs
);
496 return (ctf_set_errno (fp
, EAGAIN
));
499 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
500 hdrp
= (ctf_header_t
*) buf
;
501 hdrp
->cth_strlen
= strtab
.cts_len
;
502 buf_size
+= hdrp
->cth_strlen
;
503 ctf_free (strtab
.cts_strs
);
505 /* Finally, we are ready to ctf_simple_open() the new container. If this
506 is successful, we then switch nfp and fp and free the old container. */
508 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
509 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
513 return (ctf_set_errno (fp
, err
));
516 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
517 (void) ctf_import (nfp
, fp
->ctf_parent
);
519 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
520 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
521 if (nfp
->ctf_dynbase
== NULL
)
522 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
523 nfp
->ctf_dthash
= fp
->ctf_dthash
;
524 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
525 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
526 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
527 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
528 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
529 nfp
->ctf_specific
= fp
->ctf_specific
;
530 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
531 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
532 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
533 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
534 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
535 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
536 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
537 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
538 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
539 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
541 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
543 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
544 nfp
->ctf_structs
= fp
->ctf_structs
;
545 nfp
->ctf_unions
= fp
->ctf_unions
;
546 nfp
->ctf_enums
= fp
->ctf_enums
;
547 nfp
->ctf_names
= fp
->ctf_names
;
549 fp
->ctf_dthash
= NULL
;
550 ctf_str_free_atoms (nfp
);
551 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
552 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
553 fp
->ctf_str_atoms
= NULL
;
554 fp
->ctf_prov_strtab
= NULL
;
555 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
556 fp
->ctf_ptrtab
= NULL
;
557 fp
->ctf_link_inputs
= NULL
;
558 fp
->ctf_link_outputs
= NULL
;
559 fp
->ctf_syn_ext_strtab
= NULL
;
560 fp
->ctf_link_cu_mapping
= NULL
;
561 fp
->ctf_link_type_mapping
= NULL
;
563 fp
->ctf_dvhash
= NULL
;
564 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
565 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
566 fp
->ctf_structs
.ctn_writable
= NULL
;
567 fp
->ctf_unions
.ctn_writable
= NULL
;
568 fp
->ctf_enums
.ctn_writable
= NULL
;
569 fp
->ctf_names
.ctn_writable
= NULL
;
571 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
572 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
573 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
575 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
576 ctf_file_close (nfp
);
582 ctf_name_table (ctf_file_t
*fp
, int kind
)
587 return &fp
->ctf_structs
;
589 return &fp
->ctf_unions
;
591 return &fp
->ctf_enums
;
593 return &fp
->ctf_names
;
598 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int kind
)
601 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
604 if (dtd
->dtd_data
.ctt_name
605 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
607 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
608 (char *) name
, (void *) dtd
->dtd_type
) < 0)
610 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
614 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
619 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
621 ctf_dmdef_t
*dmd
, *nmd
;
622 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
625 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
632 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
633 dmd
!= NULL
; dmd
= nmd
)
635 if (dmd
->dmd_name
!= NULL
)
636 ctf_free (dmd
->dmd_name
);
637 nmd
= ctf_list_next (dmd
);
642 ctf_free (dtd
->dtd_u
.dtu_argv
);
646 if (dtd
->dtd_data
.ctt_name
647 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
649 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
651 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
654 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
659 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
661 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
665 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
669 if (!(fp
->ctf_flags
& LCTF_RDWR
))
672 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
675 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
677 if ((unsigned long) idx
<= fp
->ctf_typemax
)
678 return ctf_dtd_lookup (fp
, id
);
683 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
685 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
687 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
692 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
694 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
695 ctf_free (dvd
->dvd_name
);
697 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
702 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
704 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
707 /* Discard all of the dynamic type definitions and variable definitions that
708 have been added to the container since the last call to ctf_update(). We
709 locate such types by scanning the dtd list and deleting elements that have
710 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
711 by scanning the variable list and deleting elements that have update IDs
712 equal to the current value of the last-update snapshot count (indicating that
713 they were added after the most recent call to ctf_update()). */
715 ctf_discard (ctf_file_t
*fp
)
717 ctf_snapshot_id_t last_update
=
719 fp
->ctf_snapshot_lu
+ 1 };
721 /* Update required? */
722 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
725 return (ctf_rollback (fp
, last_update
));
729 ctf_snapshot (ctf_file_t
*fp
)
731 ctf_snapshot_id_t snapid
;
732 snapid
.dtd_id
= fp
->ctf_typemax
;
733 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
737 /* Like ctf_discard(), only discards everything after a particular ID. */
739 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
741 ctf_dtdef_t
*dtd
, *ntd
;
742 ctf_dvdef_t
*dvd
, *nvd
;
744 if (!(fp
->ctf_flags
& LCTF_RDWR
))
745 return (ctf_set_errno (fp
, ECTF_RDONLY
));
747 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
748 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
750 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
755 ntd
= ctf_list_next (dtd
);
757 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
760 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
762 if (dtd
->dtd_data
.ctt_name
763 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
765 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
767 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
770 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
771 ctf_dtd_delete (fp
, dtd
);
774 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
776 nvd
= ctf_list_next (dvd
);
778 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
781 ctf_dvd_delete (fp
, dvd
);
784 fp
->ctf_typemax
= id
.dtd_id
;
785 fp
->ctf_snapshots
= id
.snapshot_id
;
787 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
788 fp
->ctf_flags
&= ~LCTF_DIRTY
;
794 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
800 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
801 return (ctf_set_errno (fp
, EINVAL
));
803 if (!(fp
->ctf_flags
& LCTF_RDWR
))
804 return (ctf_set_errno (fp
, ECTF_RDONLY
));
806 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
807 return (ctf_set_errno (fp
, ECTF_FULL
));
809 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
810 return (ctf_set_errno (fp
, ECTF_FULL
));
812 /* Make sure ptrtab always grows to be big enough for all types. */
813 if (ctf_grow_ptrtab (fp
) < 0)
814 return CTF_ERR
; /* errno is set for us. */
816 if ((dtd
= ctf_alloc (sizeof (ctf_dtdef_t
))) == NULL
)
817 return (ctf_set_errno (fp
, EAGAIN
));
819 type
= ++fp
->ctf_typemax
;
820 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
822 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
823 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
824 dtd
->dtd_type
= type
;
826 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
829 return (ctf_set_errno (fp
, EAGAIN
));
832 if (ctf_dtd_insert (fp
, dtd
, kind
) < 0)
835 return CTF_ERR
; /* errno is set for us. */
837 fp
->ctf_flags
|= LCTF_DIRTY
;
843 /* When encoding integer sizes, we want to convert a byte count in the range
844 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
845 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
861 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
862 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
868 return (ctf_set_errno (fp
, EINVAL
));
870 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
871 return CTF_ERR
; /* errno is set for us. */
873 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
874 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
876 dtd
->dtd_u
.dtu_enc
= *ep
;
882 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
886 ctf_file_t
*tmp
= fp
;
887 int child
= fp
->ctf_flags
& LCTF_CHILD
;
889 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
890 return (ctf_set_errno (fp
, EINVAL
));
892 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
893 return CTF_ERR
; /* errno is set for us. */
895 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
896 return CTF_ERR
; /* errno is set for us. */
898 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
899 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
901 if (kind
!= CTF_K_POINTER
)
904 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
905 type and (if an anonymous typedef node is being pointed at) the type that
906 points at too. Note that ctf_typemax is at this point one higher than we
907 want to check against, because it's just been incremented for the addition
910 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
911 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
913 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
914 && ref_idx
< fp
->ctf_typemax
)
916 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
918 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
921 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
922 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
923 && refref_idx
< fp
->ctf_typemax
)
924 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
931 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
932 const ctf_encoding_t
*ep
)
937 const ctf_type_t
*tp
;
938 ctf_file_t
*tmp
= fp
;
941 return (ctf_set_errno (fp
, EINVAL
));
943 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
944 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
946 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
947 return (ctf_set_errno (fp
, EINVAL
));
949 if ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
)
950 return CTF_ERR
; /* errno is set for us. */
952 kind
= ctf_type_kind_unsliced (tmp
, ref
);
953 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
954 (kind
!= CTF_K_ENUM
))
955 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
957 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
958 return CTF_ERR
; /* errno is set for us. */
960 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
961 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
963 dtd
->dtd_u
.dtu_slice
.cts_type
= ref
;
964 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
965 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
971 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
972 const char *name
, const ctf_encoding_t
*ep
)
974 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
978 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
979 const char *name
, const ctf_encoding_t
*ep
)
981 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
985 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
987 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
991 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
995 ctf_file_t
*tmp
= fp
;
998 return (ctf_set_errno (fp
, EINVAL
));
1000 if (ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1001 return CTF_ERR
; /* errno is set for us. */
1004 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1005 return CTF_ERR
; /* errno is set for us. */
1007 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1008 return CTF_ERR
; /* errno is set for us. */
1010 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1011 dtd
->dtd_data
.ctt_size
= 0;
1012 dtd
->dtd_u
.dtu_arr
= *arp
;
1018 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1020 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1022 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1023 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1026 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1027 return (ctf_set_errno (fp
, ECTF_BADID
));
1029 fp
->ctf_flags
|= LCTF_DIRTY
;
1030 dtd
->dtd_u
.dtu_arr
= *arp
;
1036 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1037 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1042 ctf_id_t
*vdat
= NULL
;
1043 ctf_file_t
*tmp
= fp
;
1046 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1047 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1048 return (ctf_set_errno (fp
, EINVAL
));
1050 vlen
= ctc
->ctc_argc
;
1051 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1052 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1054 if (ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1055 return CTF_ERR
; /* errno is set for us. */
1057 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1060 if (ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1061 return CTF_ERR
; /* errno is set for us. */
1064 if (vlen
> CTF_MAX_VLEN
)
1065 return (ctf_set_errno (fp
, EOVERFLOW
));
1067 if (vlen
!= 0 && (vdat
= ctf_alloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1068 return (ctf_set_errno (fp
, EAGAIN
));
1070 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1074 return CTF_ERR
; /* errno is set for us. */
1077 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1078 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1080 memcpy (vdat
, argv
, sizeof (ctf_id_t
) * ctc
->ctc_argc
);
1081 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1082 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1083 dtd
->dtd_u
.dtu_argv
= vdat
;
1089 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1095 /* Promote forwards to structs. */
1098 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1100 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1101 dtd
= ctf_dtd_lookup (fp
, type
);
1102 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1104 return CTF_ERR
; /* errno is set for us. */
1106 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1108 if (size
> CTF_MAX_SIZE
)
1110 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1111 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1112 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1115 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1121 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1123 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1127 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1133 /* Promote forwards to unions. */
1135 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1137 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1138 dtd
= ctf_dtd_lookup (fp
, type
);
1139 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1141 return CTF_ERR
; /* errno is set for us */
1143 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1145 if (size
> CTF_MAX_SIZE
)
1147 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1148 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1149 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1152 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1158 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1160 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1164 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1169 /* Promote forwards to enums. */
1171 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1173 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1174 dtd
= ctf_dtd_lookup (fp
, type
);
1175 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1177 return CTF_ERR
; /* errno is set for us. */
1179 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1180 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1186 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1187 const ctf_encoding_t
*ep
)
1191 /* First, create the enum if need be, using most of the same machinery as
1192 ctf_add_enum(), to ensure that we do not allow things past that are not
1193 enums or forwards to them. (This includes other slices: you cannot slice a
1194 slice, which would be a useless thing to do anyway.) */
1197 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1201 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1202 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1203 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1205 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1206 return CTF_ERR
; /* errno is set for us. */
1208 /* Now attach a suitable slice to it. */
1210 return ctf_add_slice (fp
, flag
, type
, ep
);
1214 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1220 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
&& kind
!= CTF_K_ENUM
)
1221 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1223 /* If the type is already defined or exists as a forward tag, just
1224 return the ctf_id_t of the existing definition. */
1227 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1229 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_FORWARD
,&dtd
)) == CTF_ERR
)
1230 return CTF_ERR
; /* errno is set for us. */
1232 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1233 dtd
->dtd_data
.ctt_type
= kind
;
1239 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1244 ctf_file_t
*tmp
= fp
;
1246 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1247 return (ctf_set_errno (fp
, EINVAL
));
1249 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1250 return CTF_ERR
; /* errno is set for us. */
1252 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1254 return CTF_ERR
; /* errno is set for us. */
1256 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1257 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1263 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1265 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1269 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1271 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1275 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1277 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1281 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1284 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1287 uint32_t kind
, vlen
, root
;
1291 return (ctf_set_errno (fp
, EINVAL
));
1293 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1294 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1297 return (ctf_set_errno (fp
, ECTF_BADID
));
1299 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1300 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1301 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1303 if (kind
!= CTF_K_ENUM
)
1304 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1306 if (vlen
== CTF_MAX_VLEN
)
1307 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1309 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1310 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1312 if (strcmp (dmd
->dmd_name
, name
) == 0)
1313 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1316 if ((dmd
= ctf_alloc (sizeof (ctf_dmdef_t
))) == NULL
)
1317 return (ctf_set_errno (fp
, EAGAIN
));
1319 if ((s
= ctf_strdup (name
)) == NULL
)
1322 return (ctf_set_errno (fp
, EAGAIN
));
1326 dmd
->dmd_type
= CTF_ERR
;
1327 dmd
->dmd_offset
= 0;
1328 dmd
->dmd_value
= value
;
1330 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1331 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1333 fp
->ctf_flags
|= LCTF_DIRTY
;
1339 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1340 ctf_id_t type
, unsigned long bit_offset
)
1342 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1345 ssize_t msize
, malign
, ssize
;
1346 uint32_t kind
, vlen
, root
;
1349 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1350 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1353 return (ctf_set_errno (fp
, ECTF_BADID
));
1355 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1356 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1357 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1359 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1360 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1362 if (vlen
== CTF_MAX_VLEN
)
1363 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1367 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1368 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1370 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1371 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1375 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1376 (malign
= ctf_type_align (fp
, type
)) < 0)
1377 return -1; /* errno is set for us. */
1379 if ((dmd
= ctf_alloc (sizeof (ctf_dmdef_t
))) == NULL
)
1380 return (ctf_set_errno (fp
, EAGAIN
));
1382 if (name
!= NULL
&& (s
= ctf_strdup (name
)) == NULL
)
1385 return (ctf_set_errno (fp
, EAGAIN
));
1389 dmd
->dmd_type
= type
;
1390 dmd
->dmd_value
= -1;
1392 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1394 if (bit_offset
== (unsigned long) - 1)
1396 /* Natural alignment. */
1398 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1399 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1400 size_t off
= lmd
->dmd_offset
;
1402 ctf_encoding_t linfo
;
1405 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1406 off
+= linfo
.cte_bits
;
1407 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1408 off
+= lsize
* CHAR_BIT
;
1410 /* Round up the offset of the end of the last member to
1411 the next byte boundary, convert 'off' to bytes, and
1412 then round it up again to the next multiple of the
1413 alignment required by the new member. Finally,
1414 convert back to bits and store the result in
1415 dmd_offset. Technically we could do more efficient
1416 packing if the new member is a bit-field, but we're
1417 the "compiler" and ANSI says we can do as we choose. */
1419 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1420 off
= roundup (off
, MAX (malign
, 1));
1421 dmd
->dmd_offset
= off
* CHAR_BIT
;
1422 ssize
= off
+ msize
;
1426 /* Specified offset in bits. */
1428 dmd
->dmd_offset
= bit_offset
;
1429 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1430 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1435 dmd
->dmd_offset
= 0;
1436 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1437 ssize
= MAX (ssize
, msize
);
1440 if ((size_t) ssize
> CTF_MAX_SIZE
)
1442 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1443 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1444 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1447 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1449 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1450 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1452 fp
->ctf_flags
|= LCTF_DIRTY
;
1457 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1458 ctf_id_t type
, unsigned long bit_offset
,
1459 const ctf_encoding_t encoding
)
1461 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1462 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1465 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1466 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1468 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1469 return -1; /* errno is set for us. */
1471 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1475 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1478 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1482 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1485 ctf_file_t
*tmp
= fp
;
1487 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1488 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1490 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1491 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1493 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1494 return -1; /* errno is set for us. */
1496 /* Make sure this type is representable. */
1497 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1498 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1501 if ((dvd
= ctf_alloc (sizeof (ctf_dvdef_t
))) == NULL
)
1502 return (ctf_set_errno (fp
, EAGAIN
));
1504 if (name
!= NULL
&& (dvd
->dvd_name
= ctf_strdup (name
)) == NULL
)
1507 return (ctf_set_errno (fp
, EAGAIN
));
1509 dvd
->dvd_type
= ref
;
1510 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1512 if (ctf_dvd_insert (fp
, dvd
) < 0)
1515 return -1; /* errno is set for us. */
1518 fp
->ctf_flags
|= LCTF_DIRTY
;
1523 enumcmp (const char *name
, int value
, void *arg
)
1525 ctf_bundle_t
*ctb
= arg
;
1528 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1530 ctf_dprintf ("Conflict due to member %s iteration error.\n", name
);
1533 if (value
!= bvalue
)
1535 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1543 enumadd (const char *name
, int value
, void *arg
)
1545 ctf_bundle_t
*ctb
= arg
;
1547 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1552 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1555 ctf_bundle_t
*ctb
= arg
;
1558 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1560 ctf_dprintf ("Conflict due to member %s iteration error.\n", name
);
1563 if (ctm
.ctm_offset
!= offset
)
1565 ctf_dprintf ("Conflict due to member %s offset change: "
1566 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1573 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1575 ctf_bundle_t
*ctb
= arg
;
1579 if ((dmd
= ctf_alloc (sizeof (ctf_dmdef_t
))) == NULL
)
1580 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1582 if (name
!= NULL
&& (s
= ctf_strdup (name
)) == NULL
)
1585 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1588 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1589 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1591 dmd
->dmd_type
= type
;
1592 dmd
->dmd_offset
= offset
;
1593 dmd
->dmd_value
= -1;
1595 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1597 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1601 /* The ctf_add_type routine is used to copy a type from a source CTF container
1602 to a dynamic destination container. This routine operates recursively by
1603 following the source type's links and embedded member types. If the
1604 destination container already contains a named type which has the same
1605 attributes, then we succeed and return this type but no changes occur. */
1607 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
1609 ctf_id_t dst_type
= CTF_ERR
;
1610 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1614 uint32_t kind
, forward_kind
, flag
, vlen
;
1616 const ctf_type_t
*src_tp
, *dst_tp
;
1617 ctf_bundle_t src
, dst
;
1618 ctf_encoding_t src_en
, dst_en
;
1619 ctf_arinfo_t src_ar
, dst_ar
;
1624 ctf_id_t orig_src_type
= src_type
;
1626 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1627 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1629 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1630 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1632 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1633 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1634 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1636 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1637 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1638 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1639 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1641 forward_kind
= kind
;
1642 if (kind
== CTF_K_FORWARD
)
1643 forward_kind
= src_tp
->ctt_type
;
1645 /* If the source type has a name and is a root type (visible at the
1646 top-level scope), lookup the name in the destination container and
1647 verify that it is of the same kind before we do anything else. */
1649 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1650 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1653 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1656 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1657 unless dst_type is a forward declaration and src_type is a struct,
1658 union, or enum (i.e. the definition of the previous forward decl).
1660 We also allow addition in the opposite order (addition of a forward when a
1661 struct, union, or enum already exists), which is a NOP and returns the
1662 already-present struct, union, or enum. */
1664 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1666 if (kind
== CTF_K_FORWARD
1667 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1668 || dst_kind
== CTF_K_UNION
))
1670 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1674 if (dst_kind
!= CTF_K_FORWARD
1675 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1676 && kind
!= CTF_K_UNION
))
1678 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1679 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1680 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1684 /* We take special action for an integer, float, or slice since it is
1685 described not only by its name but also its encoding. For integers,
1686 bit-fields exploit this degeneracy. */
1688 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1690 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1691 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1693 if (dst_type
!= CTF_ERR
)
1695 ctf_file_t
*fp
= dst_fp
;
1697 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1700 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1702 /* The type that we found in the hash is also root-visible. If
1703 the two types match then use the existing one; otherwise,
1704 declare a conflict. Note: slices are not certain to match
1705 even if there is no conflict: we must check the contained type
1708 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1709 return CTF_ERR
; /* errno set for us. */
1711 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1713 if (kind
!= CTF_K_SLICE
)
1715 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1721 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1726 /* We found a non-root-visible type in the hash. We reset
1727 dst_type to ensure that we continue to look for a possible
1728 conflict in the pending list. */
1735 /* If the non-empty name was not found in the appropriate hash, search
1736 the list of pending dynamic definitions that are not yet committed.
1737 If a matching name and kind are found, assume this is the type that
1738 we are looking for. This is necessary to permit ctf_add_type() to
1739 operate recursively on entities such as a struct that contains a
1740 pointer member that refers to the same struct type. */
1742 if (dst_type
== CTF_ERR
&& name
[0] != '\0')
1744 for (dtd
= ctf_list_prev (&dst_fp
->ctf_dtdefs
); dtd
!= NULL
1745 && LCTF_TYPE_TO_INDEX (src_fp
, dtd
->dtd_type
) > dst_fp
->ctf_dtoldid
;
1746 dtd
= ctf_list_prev (dtd
))
1748 const char *ctt_name
;
1750 if (LCTF_INFO_KIND (src_fp
, dtd
->dtd_data
.ctt_info
) == kind
1751 && dtd
->dtd_data
.ctt_name
1752 && ((ctt_name
= ctf_strraw (src_fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
1753 && strcmp (ctt_name
, name
) == 0)
1755 int sroot
; /* Is the src root-visible? */
1756 int droot
; /* Is the dst root-visible? */
1757 int match
; /* Do the encodings match? */
1759 if (kind
!= CTF_K_INTEGER
&& kind
!= CTF_K_FLOAT
&& kind
!= CTF_K_SLICE
)
1761 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dtd
->dtd_type
);
1762 return dtd
->dtd_type
;
1765 sroot
= (flag
& CTF_ADD_ROOT
);
1766 droot
= (LCTF_INFO_ISROOT (dst_fp
,
1768 ctt_info
) & CTF_ADD_ROOT
);
1770 match
= (memcmp (&src_en
, &dtd
->dtd_u
.dtu_enc
,
1771 sizeof (ctf_encoding_t
)) == 0);
1773 /* If the types share the same encoding then return the id of the
1774 first unless one type is root-visible and the other is not; in
1775 that case the new type must get a new id if a match is never
1776 found. Note: slices are not certain to match even if there is
1777 no conflict: we must check the contained type too. */
1779 if (match
&& sroot
== droot
)
1781 if (kind
!= CTF_K_SLICE
)
1783 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dtd
->dtd_type
);
1784 return dtd
->dtd_type
;
1787 else if (!match
&& sroot
&& droot
)
1789 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1795 src
.ctb_file
= src_fp
;
1796 src
.ctb_type
= src_type
;
1799 dst
.ctb_file
= dst_fp
;
1800 dst
.ctb_type
= dst_type
;
1803 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then
1804 we add a new type with the same properties as src_type to dst_fp.
1805 If dst_type is not CTF_ERR, then we verify that dst_type has the
1806 same attributes as src_type. We recurse for embedded references. */
1810 /* If we found a match we will have either returned it or declared a
1812 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1816 /* If we found a match we will have either returned it or declared a
1818 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1822 /* We have checked for conflicting encodings: now try to add the
1824 src_type
= ctf_type_reference (src_fp
, src_type
);
1825 dst_type
= ctf_add_type (dst_fp
, src_fp
, src_type
);
1827 if (src_type
== CTF_ERR
)
1828 return CTF_ERR
; /* errno is set for us. */
1830 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1834 case CTF_K_VOLATILE
:
1836 case CTF_K_RESTRICT
:
1837 src_type
= ctf_type_reference (src_fp
, src_type
);
1838 src_type
= ctf_add_type (dst_fp
, src_fp
, src_type
);
1840 if (src_type
== CTF_ERR
)
1841 return CTF_ERR
; /* errno is set for us. */
1843 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1847 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1848 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1850 src_ar
.ctr_contents
=
1851 ctf_add_type (dst_fp
, src_fp
, src_ar
.ctr_contents
);
1852 src_ar
.ctr_index
= ctf_add_type (dst_fp
, src_fp
, src_ar
.ctr_index
);
1853 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1855 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1856 return CTF_ERR
; /* errno is set for us. */
1858 if (dst_type
!= CTF_ERR
)
1860 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1861 return CTF_ERR
; /* errno is set for us. */
1863 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1865 ctf_dprintf ("Conflict for type %s against ID %lx: "
1866 "array info differs, old %lx/%lx/%x; "
1867 "new: %lx/%lx/%x\n", name
, dst_type
,
1868 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1869 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1870 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1871 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1875 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1878 case CTF_K_FUNCTION
:
1879 ctc
.ctc_return
= ctf_add_type (dst_fp
, src_fp
, src_tp
->ctt_type
);
1883 if (ctc
.ctc_return
== CTF_ERR
)
1884 return CTF_ERR
; /* errno is set for us. */
1886 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1897 /* Technically to match a struct or union we need to check both
1898 ways (src members vs. dst, dst members vs. src) but we make
1899 this more optimal by only checking src vs. dst and comparing
1900 the total size of the structure (which we must do anyway)
1901 which covers the possibility of dst members not in src.
1902 This optimization can be defeated for unions, but is so
1903 pathological as to render it irrelevant for our purposes. */
1905 if (dst_type
!= CTF_ERR
&& dst_kind
!= CTF_K_FORWARD
)
1907 if (ctf_type_size (src_fp
, src_type
) !=
1908 ctf_type_size (dst_fp
, dst_type
))
1910 ctf_dprintf ("Conflict for type %s against ID %lx: "
1911 "union size differs, old %li, new %li\n",
1913 (long) ctf_type_size (src_fp
, src_type
),
1914 (long) ctf_type_size (dst_fp
, dst_type
));
1915 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1918 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1920 ctf_dprintf ("Conflict for type %s against ID %lx: "
1921 "members differ, see above\n", name
, dst_type
);
1922 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1928 /* Unlike the other cases, copying structs and unions is done
1929 manually so as to avoid repeated lookups in ctf_add_member
1930 and to ensure the exact same member offsets as in src_type. */
1932 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1933 if (dst_type
== CTF_ERR
)
1934 return CTF_ERR
; /* errno is set for us. */
1936 dst
.ctb_type
= dst_type
;
1939 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
1940 errs
++; /* Increment errs and fail at bottom of case. */
1942 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
1943 return CTF_ERR
; /* errno is set for us. */
1945 size
= (size_t) ssize
;
1946 if (size
> CTF_MAX_SIZE
)
1948 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1949 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1950 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1953 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1955 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
1957 /* Make a final pass through the members changing each dmd_type (a
1958 src_fp type) to an equivalent type in dst_fp. We pass through all
1959 members, leaving any that fail set to CTF_ERR, unless they fail
1960 because they are marking a member of type not representable in this
1961 version of CTF, in which case we just want to silently omit them:
1962 no consumer can do anything with them anyway. */
1963 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1964 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1966 if ((dmd
->dmd_type
= ctf_add_type (dst_fp
, src_fp
,
1967 dmd
->dmd_type
)) == CTF_ERR
)
1969 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
1975 return CTF_ERR
; /* errno is set for us. */
1980 if (dst_type
!= CTF_ERR
&& dst_kind
!= CTF_K_FORWARD
)
1982 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
1983 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
1985 ctf_dprintf ("Conflict for enum %s against ID %lx: "
1986 "members differ, see above\n", name
, dst_type
);
1987 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1992 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
1993 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
1994 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
1995 return CTF_ERR
; /* errno is set for us */
2000 if (dst_type
== CTF_ERR
)
2001 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2005 src_type
= ctf_type_reference (src_fp
, src_type
);
2006 src_type
= ctf_add_type (dst_fp
, src_fp
, src_type
);
2008 if (src_type
== CTF_ERR
)
2009 return CTF_ERR
; /* errno is set for us. */
2011 /* If dst_type is not CTF_ERR at this point, we should check if
2012 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2013 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2014 that vary based on things like if 32-bit then pid_t is int otherwise
2015 long. We therefore omit this check and assume that if the identically
2016 named typedef already exists in dst_fp, it is correct or
2019 if (dst_type
== CTF_ERR
)
2021 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2026 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2029 if (dst_type
!= CTF_ERR
)
2030 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2034 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2036 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2038 const unsigned char *buf
;
2042 resid
= sizeof (ctf_header_t
);
2043 buf
= (unsigned char *) fp
->ctf_header
;
2046 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2047 return (ctf_set_errno (fp
, errno
));
2052 resid
= fp
->ctf_size
;
2056 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2057 return (ctf_set_errno (fp
, errno
));
2065 /* Compress the specified CTF data stream and write it to the specified file
2068 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2073 ctf_header_t
*hp
= &h
;
2074 ssize_t header_len
= sizeof (ctf_header_t
);
2075 ssize_t compress_len
;
2080 if (ctf_serialize (fp
) < 0)
2081 return -1; /* errno is set for us. */
2083 memcpy (hp
, fp
->ctf_header
, header_len
);
2084 hp
->cth_flags
|= CTF_F_COMPRESS
;
2085 compress_len
= compressBound (fp
->ctf_size
);
2087 if ((buf
= ctf_alloc (compress_len
)) == NULL
)
2088 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2090 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2091 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2093 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2094 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2098 while (header_len
> 0)
2100 if ((len
= write (fd
, hp
, header_len
)) < 0)
2102 err
= ctf_set_errno (fp
, errno
);
2110 while (compress_len
> 0)
2112 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2114 err
= ctf_set_errno (fp
, errno
);
2117 compress_len
-= len
;
2126 /* Optionally compress the specified CTF data stream and return it as a new
2127 dynamically-allocated string. */
2129 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2134 ssize_t header_len
= sizeof (ctf_header_t
);
2135 ssize_t compress_len
;
2138 if (ctf_serialize (fp
) < 0)
2139 return NULL
; /* errno is set for us. */
2141 compress_len
= compressBound (fp
->ctf_size
);
2142 if (fp
->ctf_size
< threshold
)
2143 compress_len
= fp
->ctf_size
;
2144 if ((buf
= malloc (compress_len
2145 + sizeof (struct ctf_header
))) == NULL
)
2147 ctf_set_errno (fp
, ENOMEM
);
2151 hp
= (ctf_header_t
*) buf
;
2152 memcpy (hp
, fp
->ctf_header
, header_len
);
2153 bp
= buf
+ sizeof (struct ctf_header
);
2154 *size
= sizeof (struct ctf_header
);
2156 if (fp
->ctf_size
< threshold
)
2158 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2159 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2160 *size
+= fp
->ctf_size
;
2164 hp
->cth_flags
|= CTF_F_COMPRESS
;
2165 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2166 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2168 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2169 ctf_set_errno (fp
, ECTF_COMPRESS
);
2173 *size
+= compress_len
;
2178 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2180 ctf_write (ctf_file_t
*fp
, int fd
)
2182 const unsigned char *buf
;
2186 if (ctf_serialize (fp
) < 0)
2187 return -1; /* errno is set for us. */
2189 resid
= sizeof (ctf_header_t
);
2190 buf
= (unsigned char *) fp
->ctf_header
;
2193 if ((len
= write (fd
, buf
, resid
)) <= 0)
2194 return (ctf_set_errno (fp
, errno
));
2199 resid
= fp
->ctf_size
;
2203 if ((len
= write (fd
, buf
, resid
)) <= 0)
2204 return (ctf_set_errno (fp
, errno
));