2 Copyright (C) 2019-2020 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 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 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_add_processing
= fp
->ctf_add_processing
;
529 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
530 nfp
->ctf_specific
= fp
->ctf_specific
;
531 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
532 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
533 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
534 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
535 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
536 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
537 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
538 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
539 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
540 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
542 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
544 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
545 nfp
->ctf_structs
= fp
->ctf_structs
;
546 nfp
->ctf_unions
= fp
->ctf_unions
;
547 nfp
->ctf_enums
= fp
->ctf_enums
;
548 nfp
->ctf_names
= fp
->ctf_names
;
550 fp
->ctf_dthash
= NULL
;
551 ctf_str_free_atoms (nfp
);
552 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
553 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
554 fp
->ctf_str_atoms
= NULL
;
555 fp
->ctf_prov_strtab
= NULL
;
556 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
557 fp
->ctf_add_processing
= NULL
;
558 fp
->ctf_ptrtab
= NULL
;
559 fp
->ctf_link_inputs
= NULL
;
560 fp
->ctf_link_outputs
= NULL
;
561 fp
->ctf_syn_ext_strtab
= NULL
;
562 fp
->ctf_link_cu_mapping
= NULL
;
563 fp
->ctf_link_type_mapping
= NULL
;
565 fp
->ctf_dvhash
= NULL
;
566 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
567 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
568 fp
->ctf_structs
.ctn_writable
= NULL
;
569 fp
->ctf_unions
.ctn_writable
= NULL
;
570 fp
->ctf_enums
.ctn_writable
= NULL
;
571 fp
->ctf_names
.ctn_writable
= NULL
;
573 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
574 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
575 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
577 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
578 ctf_file_close (nfp
);
584 ctf_name_table (ctf_file_t
*fp
, int kind
)
589 return &fp
->ctf_structs
;
591 return &fp
->ctf_unions
;
593 return &fp
->ctf_enums
;
595 return &fp
->ctf_names
;
600 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
603 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
606 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
607 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
609 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
610 (char *) name
, (void *) dtd
->dtd_type
) < 0)
612 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
616 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
621 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
623 ctf_dmdef_t
*dmd
, *nmd
;
624 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
627 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
634 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
635 dmd
!= NULL
; dmd
= nmd
)
637 if (dmd
->dmd_name
!= NULL
)
638 free (dmd
->dmd_name
);
639 nmd
= ctf_list_next (dmd
);
644 free (dtd
->dtd_u
.dtu_argv
);
648 if (dtd
->dtd_data
.ctt_name
649 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
650 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
652 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
654 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
657 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
662 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
664 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
668 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
672 if (!(fp
->ctf_flags
& LCTF_RDWR
))
675 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
678 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
680 if ((unsigned long) idx
<= fp
->ctf_typemax
)
681 return ctf_dtd_lookup (fp
, id
);
686 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
688 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
690 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
695 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
697 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
698 free (dvd
->dvd_name
);
700 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
705 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
707 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
710 /* Discard all of the dynamic type definitions and variable definitions that
711 have been added to the container since the last call to ctf_update(). We
712 locate such types by scanning the dtd list and deleting elements that have
713 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
714 by scanning the variable list and deleting elements that have update IDs
715 equal to the current value of the last-update snapshot count (indicating that
716 they were added after the most recent call to ctf_update()). */
718 ctf_discard (ctf_file_t
*fp
)
720 ctf_snapshot_id_t last_update
=
722 fp
->ctf_snapshot_lu
+ 1 };
724 /* Update required? */
725 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
728 return (ctf_rollback (fp
, last_update
));
732 ctf_snapshot (ctf_file_t
*fp
)
734 ctf_snapshot_id_t snapid
;
735 snapid
.dtd_id
= fp
->ctf_typemax
;
736 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
740 /* Like ctf_discard(), only discards everything after a particular ID. */
742 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
744 ctf_dtdef_t
*dtd
, *ntd
;
745 ctf_dvdef_t
*dvd
, *nvd
;
747 if (!(fp
->ctf_flags
& LCTF_RDWR
))
748 return (ctf_set_errno (fp
, ECTF_RDONLY
));
750 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
751 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
753 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
758 ntd
= ctf_list_next (dtd
);
760 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
763 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
765 if (dtd
->dtd_data
.ctt_name
766 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
767 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
769 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
771 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
774 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
775 ctf_dtd_delete (fp
, dtd
);
778 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
780 nvd
= ctf_list_next (dvd
);
782 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
785 ctf_dvd_delete (fp
, dvd
);
788 fp
->ctf_typemax
= id
.dtd_id
;
789 fp
->ctf_snapshots
= id
.snapshot_id
;
791 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
792 fp
->ctf_flags
&= ~LCTF_DIRTY
;
798 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
804 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
805 return (ctf_set_errno (fp
, EINVAL
));
807 if (!(fp
->ctf_flags
& LCTF_RDWR
))
808 return (ctf_set_errno (fp
, ECTF_RDONLY
));
810 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
811 return (ctf_set_errno (fp
, ECTF_FULL
));
813 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
814 return (ctf_set_errno (fp
, ECTF_FULL
));
816 /* Make sure ptrtab always grows to be big enough for all types. */
817 if (ctf_grow_ptrtab (fp
) < 0)
818 return CTF_ERR
; /* errno is set for us. */
820 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
821 return (ctf_set_errno (fp
, EAGAIN
));
823 type
= ++fp
->ctf_typemax
;
824 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
826 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
827 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
828 dtd
->dtd_type
= type
;
830 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
833 return (ctf_set_errno (fp
, EAGAIN
));
836 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
839 return CTF_ERR
; /* errno is set for us. */
841 fp
->ctf_flags
|= LCTF_DIRTY
;
847 /* When encoding integer sizes, we want to convert a byte count in the range
848 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
849 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
865 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
866 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
872 return (ctf_set_errno (fp
, EINVAL
));
874 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
875 return CTF_ERR
; /* errno is set for us. */
877 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
878 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
880 dtd
->dtd_u
.dtu_enc
= *ep
;
886 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
890 ctf_file_t
*tmp
= fp
;
891 int child
= fp
->ctf_flags
& LCTF_CHILD
;
893 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
894 return (ctf_set_errno (fp
, EINVAL
));
896 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
897 return CTF_ERR
; /* errno is set for us. */
899 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
900 return CTF_ERR
; /* errno is set for us. */
902 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
903 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
905 if (kind
!= CTF_K_POINTER
)
908 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
909 type and (if an anonymous typedef node is being pointed at) the type that
910 points at too. Note that ctf_typemax is at this point one higher than we
911 want to check against, because it's just been incremented for the addition
914 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
915 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
917 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
918 && ref_idx
< fp
->ctf_typemax
)
920 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
922 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
925 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
926 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
927 && refref_idx
< fp
->ctf_typemax
)
928 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
935 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
936 const ctf_encoding_t
*ep
)
941 const ctf_type_t
*tp
;
942 ctf_file_t
*tmp
= fp
;
945 return (ctf_set_errno (fp
, EINVAL
));
947 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
948 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
950 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
951 return (ctf_set_errno (fp
, EINVAL
));
953 if ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
)
954 return CTF_ERR
; /* errno is set for us. */
956 kind
= ctf_type_kind_unsliced (tmp
, ref
);
957 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
958 (kind
!= CTF_K_ENUM
))
959 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
961 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
962 return CTF_ERR
; /* errno is set for us. */
964 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
965 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
967 dtd
->dtd_u
.dtu_slice
.cts_type
= ref
;
968 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
969 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
975 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
976 const char *name
, const ctf_encoding_t
*ep
)
978 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
982 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
983 const char *name
, const ctf_encoding_t
*ep
)
985 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
989 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
991 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
995 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
999 ctf_file_t
*tmp
= fp
;
1002 return (ctf_set_errno (fp
, EINVAL
));
1004 if (ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1005 return CTF_ERR
; /* errno is set for us. */
1008 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1009 return CTF_ERR
; /* errno is set for us. */
1011 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1012 return CTF_ERR
; /* errno is set for us. */
1014 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1015 dtd
->dtd_data
.ctt_size
= 0;
1016 dtd
->dtd_u
.dtu_arr
= *arp
;
1022 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1024 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1026 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1027 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1030 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1031 return (ctf_set_errno (fp
, ECTF_BADID
));
1033 fp
->ctf_flags
|= LCTF_DIRTY
;
1034 dtd
->dtd_u
.dtu_arr
= *arp
;
1040 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1041 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1046 ctf_id_t
*vdat
= NULL
;
1047 ctf_file_t
*tmp
= fp
;
1050 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1051 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1052 return (ctf_set_errno (fp
, EINVAL
));
1054 vlen
= ctc
->ctc_argc
;
1055 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1056 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1058 if (ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1059 return CTF_ERR
; /* errno is set for us. */
1061 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1064 if (ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1065 return CTF_ERR
; /* errno is set for us. */
1068 if (vlen
> CTF_MAX_VLEN
)
1069 return (ctf_set_errno (fp
, EOVERFLOW
));
1071 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1072 return (ctf_set_errno (fp
, EAGAIN
));
1074 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1078 return CTF_ERR
; /* errno is set for us. */
1081 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1082 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1084 memcpy (vdat
, argv
, sizeof (ctf_id_t
) * ctc
->ctc_argc
);
1085 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1086 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1087 dtd
->dtd_u
.dtu_argv
= vdat
;
1093 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1099 /* Promote root-visible forwards to structs. */
1101 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1103 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1104 dtd
= ctf_dtd_lookup (fp
, type
);
1105 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1107 return CTF_ERR
; /* errno is set for us. */
1109 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1111 if (size
> CTF_MAX_SIZE
)
1113 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1114 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1115 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1118 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1124 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1126 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1130 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1136 /* Promote root-visible forwards to unions. */
1138 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1140 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1141 dtd
= ctf_dtd_lookup (fp
, type
);
1142 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1144 return CTF_ERR
; /* errno is set for us */
1146 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1148 if (size
> CTF_MAX_SIZE
)
1150 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1151 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1152 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1155 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1161 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1163 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1167 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1172 /* Promote root-visible forwards to enums. */
1174 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1176 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1177 dtd
= ctf_dtd_lookup (fp
, type
);
1178 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1180 return CTF_ERR
; /* errno is set for us. */
1182 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1183 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1189 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1190 const ctf_encoding_t
*ep
)
1194 /* First, create the enum if need be, using most of the same machinery as
1195 ctf_add_enum(), to ensure that we do not allow things past that are not
1196 enums or forwards to them. (This includes other slices: you cannot slice a
1197 slice, which would be a useless thing to do anyway.) */
1200 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1204 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1205 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1206 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1208 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1209 return CTF_ERR
; /* errno is set for us. */
1211 /* Now attach a suitable slice to it. */
1213 return ctf_add_slice (fp
, flag
, type
, ep
);
1217 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1223 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
&& kind
!= CTF_K_ENUM
)
1224 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1226 /* If the type is already defined or exists as a forward tag, just
1227 return the ctf_id_t of the existing definition. */
1230 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1232 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_FORWARD
,&dtd
)) == CTF_ERR
)
1233 return CTF_ERR
; /* errno is set for us. */
1235 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1236 dtd
->dtd_data
.ctt_type
= kind
;
1242 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1247 ctf_file_t
*tmp
= fp
;
1249 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1250 return (ctf_set_errno (fp
, EINVAL
));
1252 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1253 return CTF_ERR
; /* errno is set for us. */
1255 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1257 return CTF_ERR
; /* errno is set for us. */
1259 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1260 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1266 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1268 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1272 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1274 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1278 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1280 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1284 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1287 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1290 uint32_t kind
, vlen
, root
;
1294 return (ctf_set_errno (fp
, EINVAL
));
1296 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1297 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1300 return (ctf_set_errno (fp
, ECTF_BADID
));
1302 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1303 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1304 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1306 if (kind
!= CTF_K_ENUM
)
1307 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1309 if (vlen
== CTF_MAX_VLEN
)
1310 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1312 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1313 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1315 if (strcmp (dmd
->dmd_name
, name
) == 0)
1316 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1319 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1320 return (ctf_set_errno (fp
, EAGAIN
));
1322 if ((s
= strdup (name
)) == NULL
)
1325 return (ctf_set_errno (fp
, EAGAIN
));
1329 dmd
->dmd_type
= CTF_ERR
;
1330 dmd
->dmd_offset
= 0;
1331 dmd
->dmd_value
= value
;
1333 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1334 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1336 fp
->ctf_flags
|= LCTF_DIRTY
;
1342 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1343 ctf_id_t type
, unsigned long bit_offset
)
1345 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1348 ssize_t msize
, malign
, ssize
;
1349 uint32_t kind
, vlen
, root
;
1352 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1353 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1356 return (ctf_set_errno (fp
, ECTF_BADID
));
1358 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1359 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1360 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1362 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1363 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1365 if (vlen
== CTF_MAX_VLEN
)
1366 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1370 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1371 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1373 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1374 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1378 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1379 (malign
= ctf_type_align (fp
, type
)) < 0)
1380 return -1; /* errno is set for us. */
1382 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1383 return (ctf_set_errno (fp
, EAGAIN
));
1385 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1388 return (ctf_set_errno (fp
, EAGAIN
));
1392 dmd
->dmd_type
= type
;
1393 dmd
->dmd_value
= -1;
1395 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1397 if (bit_offset
== (unsigned long) - 1)
1399 /* Natural alignment. */
1401 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1402 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1403 size_t off
= lmd
->dmd_offset
;
1405 ctf_encoding_t linfo
;
1408 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1409 off
+= linfo
.cte_bits
;
1410 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1411 off
+= lsize
* CHAR_BIT
;
1413 /* Round up the offset of the end of the last member to
1414 the next byte boundary, convert 'off' to bytes, and
1415 then round it up again to the next multiple of the
1416 alignment required by the new member. Finally,
1417 convert back to bits and store the result in
1418 dmd_offset. Technically we could do more efficient
1419 packing if the new member is a bit-field, but we're
1420 the "compiler" and ANSI says we can do as we choose. */
1422 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1423 off
= roundup (off
, MAX (malign
, 1));
1424 dmd
->dmd_offset
= off
* CHAR_BIT
;
1425 ssize
= off
+ msize
;
1429 /* Specified offset in bits. */
1431 dmd
->dmd_offset
= bit_offset
;
1432 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1433 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1438 dmd
->dmd_offset
= 0;
1439 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1440 ssize
= MAX (ssize
, msize
);
1443 if ((size_t) ssize
> CTF_MAX_SIZE
)
1445 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1446 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1447 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1450 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1452 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1453 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1455 fp
->ctf_flags
|= LCTF_DIRTY
;
1460 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1461 ctf_id_t type
, unsigned long bit_offset
,
1462 const ctf_encoding_t encoding
)
1464 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1465 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1468 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1469 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1471 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1472 return -1; /* errno is set for us. */
1474 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1478 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1481 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1485 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1488 ctf_file_t
*tmp
= fp
;
1490 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1491 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1493 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1494 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1496 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1497 return -1; /* errno is set for us. */
1499 /* Make sure this type is representable. */
1500 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1501 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1504 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1505 return (ctf_set_errno (fp
, EAGAIN
));
1507 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1510 return (ctf_set_errno (fp
, EAGAIN
));
1512 dvd
->dvd_type
= ref
;
1513 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1515 if (ctf_dvd_insert (fp
, dvd
) < 0)
1517 free (dvd
->dvd_name
);
1519 return -1; /* errno is set for us. */
1522 fp
->ctf_flags
|= LCTF_DIRTY
;
1527 enumcmp (const char *name
, int value
, void *arg
)
1529 ctf_bundle_t
*ctb
= arg
;
1532 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1534 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1535 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1538 if (value
!= bvalue
)
1540 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1548 enumadd (const char *name
, int value
, void *arg
)
1550 ctf_bundle_t
*ctb
= arg
;
1552 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1557 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1560 ctf_bundle_t
*ctb
= arg
;
1563 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1565 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1566 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1569 if (ctm
.ctm_offset
!= offset
)
1571 ctf_dprintf ("Conflict due to member %s offset change: "
1572 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1579 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1581 ctf_bundle_t
*ctb
= arg
;
1585 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1586 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1588 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1591 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1594 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1595 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1597 dmd
->dmd_type
= type
;
1598 dmd
->dmd_offset
= offset
;
1599 dmd
->dmd_value
= -1;
1601 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1603 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1607 /* The ctf_add_type routine is used to copy a type from a source CTF container
1608 to a dynamic destination container. This routine operates recursively by
1609 following the source type's links and embedded member types. If the
1610 destination container already contains a named type which has the same
1611 attributes, then we succeed and return this type but no changes occur. */
1613 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1614 ctf_file_t
*proc_tracking_fp
)
1616 ctf_id_t dst_type
= CTF_ERR
;
1617 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1618 ctf_file_t
*tmp_fp
= dst_fp
;
1622 uint32_t kind
, forward_kind
, flag
, vlen
;
1624 const ctf_type_t
*src_tp
, *dst_tp
;
1625 ctf_bundle_t src
, dst
;
1626 ctf_encoding_t src_en
, dst_en
;
1627 ctf_arinfo_t src_ar
, dst_ar
;
1631 ctf_id_t orig_src_type
= src_type
;
1633 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1634 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1636 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1637 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1639 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1640 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1641 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1643 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1644 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1645 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1646 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1648 /* If this is a type we are currently in the middle of adding, hand it
1649 straight back. (This lets us handle self-referential structures without
1650 considering forwards and empty structures the same as their completed
1653 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1657 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1658 (void *) (uintptr_t) src_type
))
1661 /* If this type has already been added from this container, and is the same
1662 kind and (if a struct or union) has the same number of members, hand it
1665 if ((ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1666 && (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1667 || kind
== CTF_K_ENUM
))
1669 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1670 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1675 forward_kind
= kind
;
1676 if (kind
== CTF_K_FORWARD
)
1677 forward_kind
= src_tp
->ctt_type
;
1679 /* If the source type has a name and is a root type (visible at the
1680 top-level scope), lookup the name in the destination container and
1681 verify that it is of the same kind before we do anything else. */
1683 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1684 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1687 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1690 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1691 unless dst_type is a forward declaration and src_type is a struct,
1692 union, or enum (i.e. the definition of the previous forward decl).
1694 We also allow addition in the opposite order (addition of a forward when a
1695 struct, union, or enum already exists), which is a NOP and returns the
1696 already-present struct, union, or enum. */
1698 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1700 if (kind
== CTF_K_FORWARD
1701 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1702 || dst_kind
== CTF_K_UNION
))
1704 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1708 if (dst_kind
!= CTF_K_FORWARD
1709 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1710 && kind
!= CTF_K_UNION
))
1712 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1713 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1714 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1718 /* We take special action for an integer, float, or slice since it is
1719 described not only by its name but also its encoding. For integers,
1720 bit-fields exploit this degeneracy. */
1722 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1724 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1725 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1727 if (dst_type
!= CTF_ERR
)
1729 ctf_file_t
*fp
= dst_fp
;
1731 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1734 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1735 return CTF_ERR
; /* errno set for us. */
1737 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1739 /* The type that we found in the hash is also root-visible. If
1740 the two types match then use the existing one; otherwise,
1741 declare a conflict. Note: slices are not certain to match
1742 even if there is no conflict: we must check the contained type
1745 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1747 if (kind
!= CTF_K_SLICE
)
1749 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1755 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1760 /* We found a non-root-visible type in the hash. If its encoding
1761 is the same, we can reuse it, unless it is a slice. */
1763 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1765 if (kind
!= CTF_K_SLICE
)
1767 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1775 src
.ctb_file
= src_fp
;
1776 src
.ctb_type
= src_type
;
1779 dst
.ctb_file
= dst_fp
;
1780 dst
.ctb_type
= dst_type
;
1783 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1784 a new type with the same properties as src_type to dst_fp. If dst_type is
1785 not CTF_ERR, then we verify that dst_type has the same attributes as
1786 src_type. We recurse for embedded references. Before we start, we note
1787 that we are processing this type, to prevent infinite recursion: we do not
1788 re-process any type that appears in this list. The list is emptied
1789 wholesale at the end of processing everything in this recursive stack. */
1791 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1792 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1793 return ctf_set_errno (dst_fp
, ENOMEM
);
1798 /* If we found a match we will have either returned it or declared a
1800 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1804 /* If we found a match we will have either returned it or declared a
1806 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1810 /* We have checked for conflicting encodings: now try to add the
1812 src_type
= ctf_type_reference (src_fp
, src_type
);
1813 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1816 if (src_type
== CTF_ERR
)
1817 return CTF_ERR
; /* errno is set for us. */
1819 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1823 case CTF_K_VOLATILE
:
1825 case CTF_K_RESTRICT
:
1826 src_type
= ctf_type_reference (src_fp
, src_type
);
1827 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1830 if (src_type
== CTF_ERR
)
1831 return CTF_ERR
; /* errno is set for us. */
1833 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1837 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1838 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1840 src_ar
.ctr_contents
=
1841 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1843 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1846 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1848 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1849 return CTF_ERR
; /* errno is set for us. */
1851 if (dst_type
!= CTF_ERR
)
1853 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1854 return CTF_ERR
; /* errno is set for us. */
1856 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1858 ctf_dprintf ("Conflict for type %s against ID %lx: "
1859 "array info differs, old %lx/%lx/%x; "
1860 "new: %lx/%lx/%x\n", name
, dst_type
,
1861 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1862 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1863 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1864 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1868 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1871 case CTF_K_FUNCTION
:
1872 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1878 if (ctc
.ctc_return
== CTF_ERR
)
1879 return CTF_ERR
; /* errno is set for us. */
1881 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1893 /* Technically to match a struct or union we need to check both
1894 ways (src members vs. dst, dst members vs. src) but we make
1895 this more optimal by only checking src vs. dst and comparing
1896 the total size of the structure (which we must do anyway)
1897 which covers the possibility of dst members not in src.
1898 This optimization can be defeated for unions, but is so
1899 pathological as to render it irrelevant for our purposes. */
1901 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1902 && dst_kind
!= CTF_K_FORWARD
)
1904 if (ctf_type_size (src_fp
, src_type
) !=
1905 ctf_type_size (dst_fp
, dst_type
))
1907 ctf_dprintf ("Conflict for type %s against ID %lx: "
1908 "union size differs, old %li, new %li\n",
1910 (long) ctf_type_size (src_fp
, src_type
),
1911 (long) ctf_type_size (dst_fp
, dst_type
));
1912 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1915 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1917 ctf_dprintf ("Conflict for type %s against ID %lx: "
1918 "members differ, see above\n", name
, dst_type
);
1919 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1925 /* Unlike the other cases, copying structs and unions is done
1926 manually so as to avoid repeated lookups in ctf_add_member
1927 and to ensure the exact same member offsets as in src_type. */
1929 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1930 if (dst_type
== CTF_ERR
)
1931 return CTF_ERR
; /* errno is set for us. */
1933 dst
.ctb_type
= dst_type
;
1936 /* Pre-emptively add this struct to the type mapping so that
1937 structures that refer to themselves work. */
1938 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1940 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
1941 errs
++; /* Increment errs and fail at bottom of case. */
1943 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
1944 return CTF_ERR
; /* errno is set for us. */
1946 size
= (size_t) ssize
;
1947 if (size
> CTF_MAX_SIZE
)
1949 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1950 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1951 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1954 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1956 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
1958 /* Make a final pass through the members changing each dmd_type (a
1959 src_fp type) to an equivalent type in dst_fp. We pass through all
1960 members, leaving any that fail set to CTF_ERR, unless they fail
1961 because they are marking a member of type not representable in this
1962 version of CTF, in which case we just want to silently omit them:
1963 no consumer can do anything with them anyway. */
1964 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1965 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1967 ctf_file_t
*dst
= dst_fp
;
1970 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
1973 if ((dmd
->dmd_type
=
1974 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
1975 proc_tracking_fp
)) == CTF_ERR
)
1977 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
1982 dmd
->dmd_type
= memb_type
;
1986 return CTF_ERR
; /* errno is set for us. */
1991 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1992 && dst_kind
!= CTF_K_FORWARD
)
1994 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
1995 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
1997 ctf_dprintf ("Conflict for enum %s against ID %lx: "
1998 "members differ, see above\n", name
, dst_type
);
1999 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2004 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2005 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2006 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2007 return CTF_ERR
; /* errno is set for us */
2012 if (dst_type
== CTF_ERR
)
2013 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2017 src_type
= ctf_type_reference (src_fp
, src_type
);
2018 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2021 if (src_type
== CTF_ERR
)
2022 return CTF_ERR
; /* errno is set for us. */
2024 /* If dst_type is not CTF_ERR at this point, we should check if
2025 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2026 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2027 that vary based on things like if 32-bit then pid_t is int otherwise
2028 long. We therefore omit this check and assume that if the identically
2029 named typedef already exists in dst_fp, it is correct or
2032 if (dst_type
== CTF_ERR
)
2033 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2038 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2041 if (dst_type
!= CTF_ERR
)
2042 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2047 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2051 if (!src_fp
->ctf_add_processing
)
2052 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2053 ctf_hash_eq_integer
,
2056 /* We store the hash on the source, because it contains only source type IDs:
2057 but callers will invariably expect errors to appear on the dest. */
2058 if (!src_fp
->ctf_add_processing
)
2059 return (ctf_set_errno (dst_fp
, ENOMEM
));
2061 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2062 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2067 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2069 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2071 const unsigned char *buf
;
2075 resid
= sizeof (ctf_header_t
);
2076 buf
= (unsigned char *) fp
->ctf_header
;
2079 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2080 return (ctf_set_errno (fp
, errno
));
2085 resid
= fp
->ctf_size
;
2089 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2090 return (ctf_set_errno (fp
, errno
));
2098 /* Compress the specified CTF data stream and write it to the specified file
2101 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2106 ctf_header_t
*hp
= &h
;
2107 ssize_t header_len
= sizeof (ctf_header_t
);
2108 ssize_t compress_len
;
2113 if (ctf_serialize (fp
) < 0)
2114 return -1; /* errno is set for us. */
2116 memcpy (hp
, fp
->ctf_header
, header_len
);
2117 hp
->cth_flags
|= CTF_F_COMPRESS
;
2118 compress_len
= compressBound (fp
->ctf_size
);
2120 if ((buf
= malloc (compress_len
)) == NULL
)
2121 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2123 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2124 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2126 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2127 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2131 while (header_len
> 0)
2133 if ((len
= write (fd
, hp
, header_len
)) < 0)
2135 err
= ctf_set_errno (fp
, errno
);
2143 while (compress_len
> 0)
2145 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2147 err
= ctf_set_errno (fp
, errno
);
2150 compress_len
-= len
;
2159 /* Optionally compress the specified CTF data stream and return it as a new
2160 dynamically-allocated string. */
2162 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2167 ssize_t header_len
= sizeof (ctf_header_t
);
2168 ssize_t compress_len
;
2171 if (ctf_serialize (fp
) < 0)
2172 return NULL
; /* errno is set for us. */
2174 compress_len
= compressBound (fp
->ctf_size
);
2175 if (fp
->ctf_size
< threshold
)
2176 compress_len
= fp
->ctf_size
;
2177 if ((buf
= malloc (compress_len
2178 + sizeof (struct ctf_header
))) == NULL
)
2180 ctf_set_errno (fp
, ENOMEM
);
2184 hp
= (ctf_header_t
*) buf
;
2185 memcpy (hp
, fp
->ctf_header
, header_len
);
2186 bp
= buf
+ sizeof (struct ctf_header
);
2187 *size
= sizeof (struct ctf_header
);
2189 if (fp
->ctf_size
< threshold
)
2191 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2192 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2193 *size
+= fp
->ctf_size
;
2197 hp
->cth_flags
|= CTF_F_COMPRESS
;
2198 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2199 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2201 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2202 ctf_set_errno (fp
, ECTF_COMPRESS
);
2206 *size
+= compress_len
;
2211 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2213 ctf_write (ctf_file_t
*fp
, int fd
)
2215 const unsigned char *buf
;
2219 if (ctf_serialize (fp
) < 0)
2220 return -1; /* errno is set for us. */
2222 resid
= sizeof (ctf_header_t
);
2223 buf
= (unsigned char *) fp
->ctf_header
;
2226 if ((len
= write (fd
, buf
, resid
)) <= 0)
2227 return (ctf_set_errno (fp
, errno
));
2232 resid
= fp
->ctf_size
;
2236 if ((len
= write (fd
, buf
, resid
)) <= 0)
2237 return (ctf_set_errno (fp
, errno
));