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>
28 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
31 /* Make sure the ptrtab has enough space for at least one more type.
33 We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
37 ctf_grow_ptrtab (ctf_file_t
*fp
)
39 size_t new_ptrtab_len
= fp
->ctf_ptrtab_len
;
41 /* We allocate one more ptrtab entry than we need, for the initial zero,
42 plus one because the caller will probably allocate a new type. */
44 if (fp
->ctf_ptrtab
== NULL
)
45 new_ptrtab_len
= 1024;
46 else if ((fp
->ctf_typemax
+ 2) > fp
->ctf_ptrtab_len
)
47 new_ptrtab_len
= fp
->ctf_ptrtab_len
* 1.25;
49 if (new_ptrtab_len
!= fp
->ctf_ptrtab_len
)
53 if ((new_ptrtab
= realloc (fp
->ctf_ptrtab
,
54 new_ptrtab_len
* sizeof (uint32_t))) == NULL
)
55 return (ctf_set_errno (fp
, ENOMEM
));
57 fp
->ctf_ptrtab
= new_ptrtab
;
58 memset (fp
->ctf_ptrtab
+ fp
->ctf_ptrtab_len
, 0,
59 (new_ptrtab_len
- fp
->ctf_ptrtab_len
) * sizeof (uint32_t));
60 fp
->ctf_ptrtab_len
= new_ptrtab_len
;
65 /* To create an empty CTF container, we just declare a zeroed header and call
66 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new container r/w
67 and initialize the dynamic members. We start assigning type IDs at 1 because
68 type ID 0 is used as a sentinel and a not-found indicator. */
71 ctf_create (int *errp
)
73 static const ctf_header_t hdr
= { .cth_preamble
= { CTF_MAGIC
, CTF_VERSION
, 0 } };
75 ctf_dynhash_t
*dthash
;
76 ctf_dynhash_t
*dvhash
;
77 ctf_dynhash_t
*structs
= NULL
, *unions
= NULL
, *enums
= NULL
, *names
= NULL
;
82 dthash
= ctf_dynhash_create (ctf_hash_integer
, ctf_hash_eq_integer
,
86 ctf_set_open_errno (errp
, EAGAIN
);
90 dvhash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
94 ctf_set_open_errno (errp
, EAGAIN
);
98 structs
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
100 unions
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
102 enums
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
104 names
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
106 if (!structs
|| !unions
|| !enums
|| !names
)
108 ctf_set_open_errno (errp
, EAGAIN
);
112 cts
.cts_name
= _CTF_SECTION
;
114 cts
.cts_size
= sizeof (hdr
);
117 if ((fp
= ctf_bufopen_internal (&cts
, NULL
, NULL
, NULL
, 1, errp
)) == NULL
)
120 fp
->ctf_structs
.ctn_writable
= structs
;
121 fp
->ctf_unions
.ctn_writable
= unions
;
122 fp
->ctf_enums
.ctn_writable
= enums
;
123 fp
->ctf_names
.ctn_writable
= names
;
124 fp
->ctf_dthash
= dthash
;
125 fp
->ctf_dvhash
= dvhash
;
127 fp
->ctf_snapshots
= 1;
128 fp
->ctf_snapshot_lu
= 0;
129 fp
->ctf_flags
|= LCTF_DIRTY
;
131 ctf_set_ctl_hashes (fp
);
132 ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
133 if (ctf_grow_ptrtab (fp
) < 0)
135 ctf_set_open_errno (errp
, ctf_errno (fp
));
143 ctf_dynhash_destroy (structs
);
144 ctf_dynhash_destroy (unions
);
145 ctf_dynhash_destroy (enums
);
146 ctf_dynhash_destroy (names
);
147 ctf_dynhash_destroy (dvhash
);
149 ctf_dynhash_destroy (dthash
);
154 static unsigned char *
155 ctf_copy_smembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
157 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
160 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
162 ctf_member_t
*copied
;
165 ctm
.ctm_type
= (uint32_t) dmd
->dmd_type
;
166 ctm
.ctm_offset
= (uint32_t) dmd
->dmd_offset
;
168 memcpy (t
, &ctm
, sizeof (ctm
));
169 copied
= (ctf_member_t
*) t
;
171 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctm_name
);
179 static unsigned char *
180 ctf_copy_lmembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
182 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
185 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
187 ctf_lmember_t
*copied
;
190 ctlm
.ctlm_type
= (uint32_t) dmd
->dmd_type
;
191 ctlm
.ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (dmd
->dmd_offset
);
192 ctlm
.ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (dmd
->dmd_offset
);
194 memcpy (t
, &ctlm
, sizeof (ctlm
));
195 copied
= (ctf_lmember_t
*) t
;
197 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctlm_name
);
205 static unsigned char *
206 ctf_copy_emembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
208 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
211 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
215 cte
.cte_value
= dmd
->dmd_value
;
216 memcpy (t
, &cte
, sizeof (cte
));
217 copied
= (ctf_enum_t
*) t
;
218 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->cte_name
);
225 /* Sort a newly-constructed static variable array. */
227 typedef struct ctf_sort_var_arg_cb
231 } ctf_sort_var_arg_cb_t
;
234 ctf_sort_var (const void *one_
, const void *two_
, void *arg_
)
236 const ctf_varent_t
*one
= one_
;
237 const ctf_varent_t
*two
= two_
;
238 ctf_sort_var_arg_cb_t
*arg
= arg_
;
240 return (strcmp (ctf_strraw_explicit (arg
->fp
, one
->ctv_name
, arg
->strtab
),
241 ctf_strraw_explicit (arg
->fp
, two
->ctv_name
, arg
->strtab
)));
244 /* Compatibility: just update the threshold for ctf_discard. */
246 ctf_update (ctf_file_t
*fp
)
248 if (!(fp
->ctf_flags
& LCTF_RDWR
))
249 return (ctf_set_errno (fp
, ECTF_RDONLY
));
251 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
255 /* If the specified CTF container is writable and has been modified, reload this
256 container with the updated type definitions, ready for serialization. In
257 order to make this code and the rest of libctf as simple as possible, we
258 perform updates by taking the dynamic type definitions and creating an
259 in-memory CTF file containing the definitions, and then call
260 ctf_simple_open_internal() on it. We perform one extra trick here for the
261 benefit of callers and to keep our code simple: ctf_simple_open_internal()
262 will return a new ctf_file_t, but we want to keep the fp constant for the
263 caller, so after ctf_simple_open_internal() returns, we use memcpy to swap
264 the interior of the old and new ctf_file_t's, and then free the old. */
266 ctf_serialize (ctf_file_t
*fp
)
268 ctf_file_t ofp
, *nfp
;
269 ctf_header_t hdr
, *hdrp
;
272 ctf_varent_t
*dvarents
;
273 ctf_strs_writable_t strtab
;
277 size_t buf_size
, type_size
, nvars
;
278 unsigned char *buf
, *newbuf
;
281 if (!(fp
->ctf_flags
& LCTF_RDWR
))
282 return (ctf_set_errno (fp
, ECTF_RDONLY
));
284 /* Update required? */
285 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
288 /* Fill in an initial CTF header. We will leave the label, object,
289 and function sections empty and only output a header, type section,
290 and string table. The type section begins at a 4-byte aligned
291 boundary past the CTF header itself (at relative offset zero). */
293 memset (&hdr
, 0, sizeof (hdr
));
294 hdr
.cth_magic
= CTF_MAGIC
;
295 hdr
.cth_version
= CTF_VERSION
;
297 /* Iterate through the dynamic type definition list and compute the
298 size of the CTF type section we will need to generate. */
300 for (type_size
= 0, dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
301 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
303 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
304 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
306 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
307 type_size
+= sizeof (ctf_stype_t
);
309 type_size
+= sizeof (ctf_type_t
);
315 type_size
+= sizeof (uint32_t);
318 type_size
+= sizeof (ctf_array_t
);
321 type_size
+= sizeof (ctf_slice_t
);
324 type_size
+= sizeof (uint32_t) * (vlen
+ (vlen
& 1));
328 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
329 type_size
+= sizeof (ctf_member_t
) * vlen
;
331 type_size
+= sizeof (ctf_lmember_t
) * vlen
;
334 type_size
+= sizeof (ctf_enum_t
) * vlen
;
339 /* Computing the number of entries in the CTF variable section is much
342 for (nvars
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
);
343 dvd
!= NULL
; dvd
= ctf_list_next (dvd
), nvars
++);
345 /* Compute the size of the CTF buffer we need, sans only the string table,
346 then allocate a new buffer and memcpy the finished header to the start of
347 the buffer. (We will adjust this later with strtab length info.) */
349 hdr
.cth_typeoff
= hdr
.cth_varoff
+ (nvars
* sizeof (ctf_varent_t
));
350 hdr
.cth_stroff
= hdr
.cth_typeoff
+ type_size
;
353 buf_size
= sizeof (ctf_header_t
) + hdr
.cth_stroff
+ hdr
.cth_strlen
;
355 if ((buf
= malloc (buf_size
)) == NULL
)
356 return (ctf_set_errno (fp
, EAGAIN
));
358 memcpy (buf
, &hdr
, sizeof (ctf_header_t
));
359 t
= (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_varoff
;
361 hdrp
= (ctf_header_t
*) buf
;
362 if ((fp
->ctf_flags
& LCTF_CHILD
) && (fp
->ctf_parname
!= NULL
))
363 ctf_str_add_ref (fp
, fp
->ctf_parname
, &hdrp
->cth_parname
);
364 if (fp
->ctf_cuname
!= NULL
)
365 ctf_str_add_ref (fp
, fp
->ctf_cuname
, &hdrp
->cth_cuname
);
367 /* Work over the variable list, translating everything into ctf_varent_t's and
368 prepping the string table. */
370 dvarents
= (ctf_varent_t
*) t
;
371 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
372 dvd
= ctf_list_next (dvd
), i
++)
374 ctf_varent_t
*var
= &dvarents
[i
];
376 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
377 var
->ctv_type
= (uint32_t) dvd
->dvd_type
;
381 t
+= sizeof (ctf_varent_t
) * nvars
;
383 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
385 /* We now take a final lap through the dynamic type definition list and copy
386 the appropriate type records to the output buffer, noting down the
389 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
390 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
392 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
393 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
401 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
402 len
= sizeof (ctf_stype_t
);
404 len
= sizeof (ctf_type_t
);
406 memcpy (t
, &dtd
->dtd_data
, len
);
407 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
409 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
410 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
417 if (kind
== CTF_K_INTEGER
)
419 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
420 dtd
->dtd_u
.dtu_enc
.cte_offset
,
421 dtd
->dtd_u
.dtu_enc
.cte_bits
);
425 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
426 dtd
->dtd_u
.dtu_enc
.cte_offset
,
427 dtd
->dtd_u
.dtu_enc
.cte_bits
);
429 memcpy (t
, &encoding
, sizeof (encoding
));
430 t
+= sizeof (encoding
);
434 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
435 t
+= sizeof (struct ctf_slice
);
439 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
440 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
441 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
442 memcpy (t
, &cta
, sizeof (cta
));
448 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
451 for (argc
= 0; argc
< vlen
; argc
++)
452 *argv
++ = dtd
->dtd_u
.dtu_argv
[argc
];
455 *argv
++ = 0; /* Pad to 4-byte boundary. */
457 t
= (unsigned char *) argv
;
463 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
464 t
= ctf_copy_smembers (fp
, dtd
, t
);
466 t
= ctf_copy_lmembers (fp
, dtd
, t
);
470 t
= ctf_copy_emembers (fp
, dtd
, t
);
474 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
476 /* Construct the final string table and fill out all the string refs with the
477 final offsets. Then purge the refs list, because we're about to move this
478 strtab onto the end of the buf, invalidating all the offsets. */
479 strtab
= ctf_str_write_strtab (fp
);
480 ctf_str_purge_refs (fp
);
482 if (strtab
.cts_strs
== NULL
)
485 return (ctf_set_errno (fp
, EAGAIN
));
488 /* Now the string table is constructed, we can sort the buffer of
490 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
491 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
494 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
497 free (strtab
.cts_strs
);
498 return (ctf_set_errno (fp
, EAGAIN
));
501 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
502 hdrp
= (ctf_header_t
*) buf
;
503 hdrp
->cth_strlen
= strtab
.cts_len
;
504 buf_size
+= hdrp
->cth_strlen
;
505 free (strtab
.cts_strs
);
507 /* Finally, we are ready to ctf_simple_open() the new container. If this
508 is successful, we then switch nfp and fp and free the old container. */
510 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
511 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
515 return (ctf_set_errno (fp
, err
));
518 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
519 (void) ctf_import (nfp
, fp
->ctf_parent
);
521 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
522 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
523 if (nfp
->ctf_dynbase
== NULL
)
524 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
525 nfp
->ctf_dthash
= fp
->ctf_dthash
;
526 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
527 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
528 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
529 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
530 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
531 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
532 nfp
->ctf_specific
= fp
->ctf_specific
;
533 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
534 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
535 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
536 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
537 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
538 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
539 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
540 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
541 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
542 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
544 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
546 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
547 nfp
->ctf_structs
= fp
->ctf_structs
;
548 nfp
->ctf_unions
= fp
->ctf_unions
;
549 nfp
->ctf_enums
= fp
->ctf_enums
;
550 nfp
->ctf_names
= fp
->ctf_names
;
552 fp
->ctf_dthash
= NULL
;
553 ctf_str_free_atoms (nfp
);
554 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
555 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
556 fp
->ctf_str_atoms
= NULL
;
557 fp
->ctf_prov_strtab
= NULL
;
558 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
559 fp
->ctf_add_processing
= NULL
;
560 fp
->ctf_ptrtab
= NULL
;
561 fp
->ctf_link_inputs
= NULL
;
562 fp
->ctf_link_outputs
= NULL
;
563 fp
->ctf_syn_ext_strtab
= NULL
;
564 fp
->ctf_link_cu_mapping
= NULL
;
565 fp
->ctf_link_type_mapping
= NULL
;
567 fp
->ctf_dvhash
= NULL
;
568 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
569 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
570 fp
->ctf_structs
.ctn_writable
= NULL
;
571 fp
->ctf_unions
.ctn_writable
= NULL
;
572 fp
->ctf_enums
.ctn_writable
= NULL
;
573 fp
->ctf_names
.ctn_writable
= NULL
;
575 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
576 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
577 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
579 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
580 ctf_file_close (nfp
);
586 ctf_name_table (ctf_file_t
*fp
, int kind
)
591 return &fp
->ctf_structs
;
593 return &fp
->ctf_unions
;
595 return &fp
->ctf_enums
;
597 return &fp
->ctf_names
;
602 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
605 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
608 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
609 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
611 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
612 (char *) name
, (void *) dtd
->dtd_type
) < 0)
614 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
618 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
623 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
625 ctf_dmdef_t
*dmd
, *nmd
;
626 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
627 int name_kind
= kind
;
630 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
637 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
638 dmd
!= NULL
; dmd
= nmd
)
640 if (dmd
->dmd_name
!= NULL
)
641 free (dmd
->dmd_name
);
642 nmd
= ctf_list_next (dmd
);
647 free (dtd
->dtd_u
.dtu_argv
);
650 name_kind
= dtd
->dtd_data
.ctt_type
;
654 if (dtd
->dtd_data
.ctt_name
655 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
656 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
658 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
660 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
663 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
668 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
670 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
674 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
678 if (!(fp
->ctf_flags
& LCTF_RDWR
))
681 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
684 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
686 if ((unsigned long) idx
<= fp
->ctf_typemax
)
687 return ctf_dtd_lookup (fp
, id
);
692 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
694 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
696 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
701 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
703 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
704 free (dvd
->dvd_name
);
706 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
711 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
713 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
716 /* Discard all of the dynamic type definitions and variable definitions that
717 have been added to the container since the last call to ctf_update(). We
718 locate such types by scanning the dtd list and deleting elements that have
719 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
720 by scanning the variable list and deleting elements that have update IDs
721 equal to the current value of the last-update snapshot count (indicating that
722 they were added after the most recent call to ctf_update()). */
724 ctf_discard (ctf_file_t
*fp
)
726 ctf_snapshot_id_t last_update
=
728 fp
->ctf_snapshot_lu
+ 1 };
730 /* Update required? */
731 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
734 return (ctf_rollback (fp
, last_update
));
738 ctf_snapshot (ctf_file_t
*fp
)
740 ctf_snapshot_id_t snapid
;
741 snapid
.dtd_id
= fp
->ctf_typemax
;
742 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
746 /* Like ctf_discard(), only discards everything after a particular ID. */
748 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
750 ctf_dtdef_t
*dtd
, *ntd
;
751 ctf_dvdef_t
*dvd
, *nvd
;
753 if (!(fp
->ctf_flags
& LCTF_RDWR
))
754 return (ctf_set_errno (fp
, ECTF_RDONLY
));
756 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
757 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
759 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
764 ntd
= ctf_list_next (dtd
);
766 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
769 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
770 if (kind
== CTF_K_FORWARD
)
771 kind
= dtd
->dtd_data
.ctt_type
;
773 if (dtd
->dtd_data
.ctt_name
774 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
775 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
777 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
779 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
782 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
783 ctf_dtd_delete (fp
, dtd
);
786 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
788 nvd
= ctf_list_next (dvd
);
790 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
793 ctf_dvd_delete (fp
, dvd
);
796 fp
->ctf_typemax
= id
.dtd_id
;
797 fp
->ctf_snapshots
= id
.snapshot_id
;
799 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
800 fp
->ctf_flags
&= ~LCTF_DIRTY
;
806 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
812 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
813 return (ctf_set_errno (fp
, EINVAL
));
815 if (!(fp
->ctf_flags
& LCTF_RDWR
))
816 return (ctf_set_errno (fp
, ECTF_RDONLY
));
818 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
819 return (ctf_set_errno (fp
, ECTF_FULL
));
821 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
822 return (ctf_set_errno (fp
, ECTF_FULL
));
824 /* Make sure ptrtab always grows to be big enough for all types. */
825 if (ctf_grow_ptrtab (fp
) < 0)
826 return CTF_ERR
; /* errno is set for us. */
828 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
829 return (ctf_set_errno (fp
, EAGAIN
));
831 type
= ++fp
->ctf_typemax
;
832 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
834 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
835 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
836 dtd
->dtd_type
= type
;
838 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
841 return (ctf_set_errno (fp
, EAGAIN
));
844 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
847 return CTF_ERR
; /* errno is set for us. */
849 fp
->ctf_flags
|= LCTF_DIRTY
;
855 /* When encoding integer sizes, we want to convert a byte count in the range
856 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
857 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
873 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
874 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
880 return (ctf_set_errno (fp
, EINVAL
));
882 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
883 return CTF_ERR
; /* errno is set for us. */
885 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
886 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
888 dtd
->dtd_u
.dtu_enc
= *ep
;
894 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
898 ctf_file_t
*tmp
= fp
;
899 int child
= fp
->ctf_flags
& LCTF_CHILD
;
901 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
902 return (ctf_set_errno (fp
, EINVAL
));
904 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
905 return CTF_ERR
; /* errno is set for us. */
907 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
908 return CTF_ERR
; /* errno is set for us. */
910 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
911 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
913 if (kind
!= CTF_K_POINTER
)
916 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
917 type and (if an anonymous typedef node is being pointed at) the type that
918 points at too. Note that ctf_typemax is at this point one higher than we
919 want to check against, because it's just been incremented for the addition
922 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
923 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
925 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
926 && ref_idx
< fp
->ctf_typemax
)
928 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
930 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
933 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
934 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
935 && refref_idx
< fp
->ctf_typemax
)
936 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
943 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
944 const ctf_encoding_t
*ep
)
947 ctf_id_t resolved_ref
= ref
;
950 const ctf_type_t
*tp
;
951 ctf_file_t
*tmp
= fp
;
954 return (ctf_set_errno (fp
, EINVAL
));
956 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
957 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
959 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
960 return (ctf_set_errno (fp
, EINVAL
));
962 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
963 return CTF_ERR
; /* errno is set for us. */
965 /* Make sure we ultimately point to an integral type. We also allow slices to
966 point to the unimplemented type, for now, because the compiler can emit
967 such slices, though they're not very much use. */
969 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
970 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
972 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
975 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
977 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
978 return CTF_ERR
; /* errno is set for us. */
980 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
981 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
983 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
984 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
985 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
991 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
992 const char *name
, const ctf_encoding_t
*ep
)
994 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
998 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
999 const char *name
, const ctf_encoding_t
*ep
)
1001 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1005 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1007 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1011 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1015 ctf_file_t
*tmp
= fp
;
1018 return (ctf_set_errno (fp
, EINVAL
));
1020 if (arp
->ctr_contents
!= 0
1021 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1022 return CTF_ERR
; /* errno is set for us. */
1025 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1026 return CTF_ERR
; /* errno is set for us. */
1028 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1029 return CTF_ERR
; /* errno is set for us. */
1031 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1032 dtd
->dtd_data
.ctt_size
= 0;
1033 dtd
->dtd_u
.dtu_arr
= *arp
;
1039 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1041 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1043 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1044 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1047 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1048 return (ctf_set_errno (fp
, ECTF_BADID
));
1050 fp
->ctf_flags
|= LCTF_DIRTY
;
1051 dtd
->dtd_u
.dtu_arr
= *arp
;
1057 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1058 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1063 uint32_t *vdat
= NULL
;
1064 ctf_file_t
*tmp
= fp
;
1067 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1068 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1069 return (ctf_set_errno (fp
, EINVAL
));
1071 vlen
= ctc
->ctc_argc
;
1072 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1073 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1075 if (ctc
->ctc_return
!= 0
1076 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1077 return CTF_ERR
; /* errno is set for us. */
1079 if (vlen
> CTF_MAX_VLEN
)
1080 return (ctf_set_errno (fp
, EOVERFLOW
));
1082 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1083 return (ctf_set_errno (fp
, EAGAIN
));
1085 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1088 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1091 return CTF_ERR
; /* errno is set for us. */
1093 vdat
[i
] = (uint32_t) argv
[i
];
1096 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1100 return CTF_ERR
; /* errno is set for us. */
1103 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1104 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1106 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1107 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1108 dtd
->dtd_u
.dtu_argv
= vdat
;
1114 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1120 /* Promote root-visible forwards to structs. */
1122 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1124 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1125 dtd
= ctf_dtd_lookup (fp
, type
);
1126 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1128 return CTF_ERR
; /* errno is set for us. */
1130 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1132 if (size
> CTF_MAX_SIZE
)
1134 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1135 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1136 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1139 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1145 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1147 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1151 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1157 /* Promote root-visible forwards to unions. */
1159 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1161 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1162 dtd
= ctf_dtd_lookup (fp
, type
);
1163 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1165 return CTF_ERR
; /* errno is set for us */
1167 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1169 if (size
> CTF_MAX_SIZE
)
1171 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1172 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1173 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1176 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1182 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1184 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1188 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1193 /* Promote root-visible forwards to enums. */
1195 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1197 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1198 dtd
= ctf_dtd_lookup (fp
, type
);
1199 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1201 return CTF_ERR
; /* errno is set for us. */
1203 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1204 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1210 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1211 const ctf_encoding_t
*ep
)
1215 /* First, create the enum if need be, using most of the same machinery as
1216 ctf_add_enum(), to ensure that we do not allow things past that are not
1217 enums or forwards to them. (This includes other slices: you cannot slice a
1218 slice, which would be a useless thing to do anyway.) */
1221 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1225 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1226 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1227 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1229 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1230 return CTF_ERR
; /* errno is set for us. */
1232 /* Now attach a suitable slice to it. */
1234 return ctf_add_slice (fp
, flag
, type
, ep
);
1238 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1244 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
&& kind
!= CTF_K_ENUM
)
1245 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1247 /* If the type is already defined or exists as a forward tag, just
1248 return the ctf_id_t of the existing definition. */
1251 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1256 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1257 return CTF_ERR
; /* errno is set for us. */
1259 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1260 dtd
->dtd_data
.ctt_type
= kind
;
1266 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1271 ctf_file_t
*tmp
= fp
;
1273 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1274 return (ctf_set_errno (fp
, EINVAL
));
1276 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1277 return CTF_ERR
; /* errno is set for us. */
1279 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1281 return CTF_ERR
; /* errno is set for us. */
1283 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1284 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1290 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1292 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1296 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1298 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1302 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1304 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1308 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1311 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1314 uint32_t kind
, vlen
, root
;
1318 return (ctf_set_errno (fp
, EINVAL
));
1320 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1321 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1324 return (ctf_set_errno (fp
, ECTF_BADID
));
1326 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1327 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1328 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1330 if (kind
!= CTF_K_ENUM
)
1331 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1333 if (vlen
== CTF_MAX_VLEN
)
1334 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1336 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1337 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1339 if (strcmp (dmd
->dmd_name
, name
) == 0)
1340 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1343 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1344 return (ctf_set_errno (fp
, EAGAIN
));
1346 if ((s
= strdup (name
)) == NULL
)
1349 return (ctf_set_errno (fp
, EAGAIN
));
1353 dmd
->dmd_type
= CTF_ERR
;
1354 dmd
->dmd_offset
= 0;
1355 dmd
->dmd_value
= value
;
1357 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1358 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1360 fp
->ctf_flags
|= LCTF_DIRTY
;
1366 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1367 ctf_id_t type
, unsigned long bit_offset
)
1369 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1372 ssize_t msize
, malign
, ssize
;
1373 uint32_t kind
, vlen
, root
;
1376 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1377 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1380 return (ctf_set_errno (fp
, ECTF_BADID
));
1382 if (name
!= NULL
&& name
[0] == '\0')
1385 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1386 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1387 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1389 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1390 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1392 if (vlen
== CTF_MAX_VLEN
)
1393 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1397 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1398 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1400 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1401 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1405 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1406 (malign
= ctf_type_align (fp
, type
)) < 0)
1408 /* The unimplemented type, and any type that resolves to it, has no size
1409 and no alignment: it can correspond to any number of compiler-inserted
1412 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1416 ctf_set_errno (fp
, 0);
1419 return -1; /* errno is set for us. */
1422 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1423 return (ctf_set_errno (fp
, EAGAIN
));
1425 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1428 return (ctf_set_errno (fp
, EAGAIN
));
1432 dmd
->dmd_type
= type
;
1433 dmd
->dmd_value
= -1;
1435 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1437 if (bit_offset
== (unsigned long) - 1)
1439 /* Natural alignment. */
1441 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1442 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1443 size_t off
= lmd
->dmd_offset
;
1445 ctf_encoding_t linfo
;
1448 /* Propagate any error from ctf_type_resolve. If the last member was
1449 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1450 cannot insert right after such a member without explicit offset
1451 specification, because its alignment and size is not known. */
1452 if (ltype
== CTF_ERR
)
1455 return -1; /* errno is set for us. */
1458 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1459 off
+= linfo
.cte_bits
;
1460 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1461 off
+= lsize
* CHAR_BIT
;
1463 /* Round up the offset of the end of the last member to
1464 the next byte boundary, convert 'off' to bytes, and
1465 then round it up again to the next multiple of the
1466 alignment required by the new member. Finally,
1467 convert back to bits and store the result in
1468 dmd_offset. Technically we could do more efficient
1469 packing if the new member is a bit-field, but we're
1470 the "compiler" and ANSI says we can do as we choose. */
1472 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1473 off
= roundup (off
, MAX (malign
, 1));
1474 dmd
->dmd_offset
= off
* CHAR_BIT
;
1475 ssize
= off
+ msize
;
1479 /* Specified offset in bits. */
1481 dmd
->dmd_offset
= bit_offset
;
1482 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1483 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1488 dmd
->dmd_offset
= 0;
1489 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1490 ssize
= MAX (ssize
, msize
);
1493 if ((size_t) ssize
> CTF_MAX_SIZE
)
1495 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1496 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1497 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1500 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1502 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1503 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1505 fp
->ctf_flags
|= LCTF_DIRTY
;
1510 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1511 ctf_id_t type
, unsigned long bit_offset
,
1512 const ctf_encoding_t encoding
)
1514 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1515 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1518 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1519 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1521 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1522 return -1; /* errno is set for us. */
1524 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1528 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1531 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1535 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1538 ctf_file_t
*tmp
= fp
;
1540 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1541 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1543 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1544 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1546 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1547 return -1; /* errno is set for us. */
1549 /* Make sure this type is representable. */
1550 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1551 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1554 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1555 return (ctf_set_errno (fp
, EAGAIN
));
1557 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1560 return (ctf_set_errno (fp
, EAGAIN
));
1562 dvd
->dvd_type
= ref
;
1563 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1565 if (ctf_dvd_insert (fp
, dvd
) < 0)
1567 free (dvd
->dvd_name
);
1569 return -1; /* errno is set for us. */
1572 fp
->ctf_flags
|= LCTF_DIRTY
;
1577 enumcmp (const char *name
, int value
, void *arg
)
1579 ctf_bundle_t
*ctb
= arg
;
1582 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1584 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1585 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1588 if (value
!= bvalue
)
1590 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1598 enumadd (const char *name
, int value
, void *arg
)
1600 ctf_bundle_t
*ctb
= arg
;
1602 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1607 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1610 ctf_bundle_t
*ctb
= arg
;
1613 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1618 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1620 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1621 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1624 if (ctm
.ctm_offset
!= offset
)
1626 ctf_dprintf ("Conflict due to member %s offset change: "
1627 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1634 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1636 ctf_bundle_t
*ctb
= arg
;
1640 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1641 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1643 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1646 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1649 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1650 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1652 dmd
->dmd_type
= type
;
1653 dmd
->dmd_offset
= offset
;
1654 dmd
->dmd_value
= -1;
1656 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1658 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1662 /* The ctf_add_type routine is used to copy a type from a source CTF container
1663 to a dynamic destination container. This routine operates recursively by
1664 following the source type's links and embedded member types. If the
1665 destination container already contains a named type which has the same
1666 attributes, then we succeed and return this type but no changes occur. */
1668 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1669 ctf_file_t
*proc_tracking_fp
)
1671 ctf_id_t dst_type
= CTF_ERR
;
1672 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1673 ctf_file_t
*tmp_fp
= dst_fp
;
1677 uint32_t kind
, forward_kind
, flag
, vlen
;
1679 const ctf_type_t
*src_tp
, *dst_tp
;
1680 ctf_bundle_t src
, dst
;
1681 ctf_encoding_t src_en
, dst_en
;
1682 ctf_arinfo_t src_ar
, dst_ar
;
1686 ctf_id_t orig_src_type
= src_type
;
1688 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1689 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1691 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1692 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1694 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1695 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1696 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1698 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1699 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1700 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1701 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1703 /* If this is a type we are currently in the middle of adding, hand it
1704 straight back. (This lets us handle self-referential structures without
1705 considering forwards and empty structures the same as their completed
1708 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1712 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1713 (void *) (uintptr_t) src_type
))
1716 /* If this type has already been added from this container, and is the same
1717 kind and (if a struct or union) has the same number of members, hand it
1720 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1722 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1723 || kind
== CTF_K_ENUM
)
1725 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1726 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1734 forward_kind
= kind
;
1735 if (kind
== CTF_K_FORWARD
)
1736 forward_kind
= src_tp
->ctt_type
;
1738 /* If the source type has a name and is a root type (visible at the
1739 top-level scope), lookup the name in the destination container and
1740 verify that it is of the same kind before we do anything else. */
1742 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1743 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1746 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1749 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1750 unless dst_type is a forward declaration and src_type is a struct,
1751 union, or enum (i.e. the definition of the previous forward decl).
1753 We also allow addition in the opposite order (addition of a forward when a
1754 struct, union, or enum already exists), which is a NOP and returns the
1755 already-present struct, union, or enum. */
1757 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1759 if (kind
== CTF_K_FORWARD
1760 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1761 || dst_kind
== CTF_K_UNION
))
1763 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1767 if (dst_kind
!= CTF_K_FORWARD
1768 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1769 && kind
!= CTF_K_UNION
))
1771 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1772 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1773 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1777 /* We take special action for an integer, float, or slice since it is
1778 described not only by its name but also its encoding. For integers,
1779 bit-fields exploit this degeneracy. */
1781 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1783 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1784 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1786 if (dst_type
!= CTF_ERR
)
1788 ctf_file_t
*fp
= dst_fp
;
1790 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1793 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1794 return CTF_ERR
; /* errno set for us. */
1796 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1798 /* The type that we found in the hash is also root-visible. If
1799 the two types match then use the existing one; otherwise,
1800 declare a conflict. Note: slices are not certain to match
1801 even if there is no conflict: we must check the contained type
1804 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1806 if (kind
!= CTF_K_SLICE
)
1808 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1814 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1819 /* We found a non-root-visible type in the hash. If its encoding
1820 is the same, we can reuse it, unless it is a slice. */
1822 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1824 if (kind
!= CTF_K_SLICE
)
1826 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1834 src
.ctb_file
= src_fp
;
1835 src
.ctb_type
= src_type
;
1838 dst
.ctb_file
= dst_fp
;
1839 dst
.ctb_type
= dst_type
;
1842 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1843 a new type with the same properties as src_type to dst_fp. If dst_type is
1844 not CTF_ERR, then we verify that dst_type has the same attributes as
1845 src_type. We recurse for embedded references. Before we start, we note
1846 that we are processing this type, to prevent infinite recursion: we do not
1847 re-process any type that appears in this list. The list is emptied
1848 wholesale at the end of processing everything in this recursive stack. */
1850 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1851 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1852 return ctf_set_errno (dst_fp
, ENOMEM
);
1857 /* If we found a match we will have either returned it or declared a
1859 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1863 /* If we found a match we will have either returned it or declared a
1865 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1869 /* We have checked for conflicting encodings: now try to add the
1871 src_type
= ctf_type_reference (src_fp
, src_type
);
1872 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1875 if (src_type
== CTF_ERR
)
1876 return CTF_ERR
; /* errno is set for us. */
1878 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1882 case CTF_K_VOLATILE
:
1884 case CTF_K_RESTRICT
:
1885 src_type
= ctf_type_reference (src_fp
, src_type
);
1886 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1889 if (src_type
== CTF_ERR
)
1890 return CTF_ERR
; /* errno is set for us. */
1892 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1896 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1897 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1899 src_ar
.ctr_contents
=
1900 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1902 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1905 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1907 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1908 return CTF_ERR
; /* errno is set for us. */
1910 if (dst_type
!= CTF_ERR
)
1912 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1913 return CTF_ERR
; /* errno is set for us. */
1915 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1917 ctf_dprintf ("Conflict for type %s against ID %lx: "
1918 "array info differs, old %lx/%lx/%x; "
1919 "new: %lx/%lx/%x\n", name
, dst_type
,
1920 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1921 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1922 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1923 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1927 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1930 case CTF_K_FUNCTION
:
1931 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1937 if (ctc
.ctc_return
== CTF_ERR
)
1938 return CTF_ERR
; /* errno is set for us. */
1940 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1952 /* Technically to match a struct or union we need to check both
1953 ways (src members vs. dst, dst members vs. src) but we make
1954 this more optimal by only checking src vs. dst and comparing
1955 the total size of the structure (which we must do anyway)
1956 which covers the possibility of dst members not in src.
1957 This optimization can be defeated for unions, but is so
1958 pathological as to render it irrelevant for our purposes. */
1960 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1961 && dst_kind
!= CTF_K_FORWARD
)
1963 if (ctf_type_size (src_fp
, src_type
) !=
1964 ctf_type_size (dst_fp
, dst_type
))
1966 ctf_dprintf ("Conflict for type %s against ID %lx: "
1967 "union size differs, old %li, new %li\n",
1969 (long) ctf_type_size (src_fp
, src_type
),
1970 (long) ctf_type_size (dst_fp
, dst_type
));
1971 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1974 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1976 ctf_dprintf ("Conflict for type %s against ID %lx: "
1977 "members differ, see above\n", name
, dst_type
);
1978 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1984 /* Unlike the other cases, copying structs and unions is done
1985 manually so as to avoid repeated lookups in ctf_add_member
1986 and to ensure the exact same member offsets as in src_type. */
1988 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1989 if (dst_type
== CTF_ERR
)
1990 return CTF_ERR
; /* errno is set for us. */
1992 dst
.ctb_type
= dst_type
;
1995 /* Pre-emptively add this struct to the type mapping so that
1996 structures that refer to themselves work. */
1997 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1999 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2000 errs
++; /* Increment errs and fail at bottom of case. */
2002 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2003 return CTF_ERR
; /* errno is set for us. */
2005 size
= (size_t) ssize
;
2006 if (size
> CTF_MAX_SIZE
)
2008 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2009 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2010 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2013 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2015 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2017 /* Make a final pass through the members changing each dmd_type (a
2018 src_fp type) to an equivalent type in dst_fp. We pass through all
2019 members, leaving any that fail set to CTF_ERR, unless they fail
2020 because they are marking a member of type not representable in this
2021 version of CTF, in which case we just want to silently omit them:
2022 no consumer can do anything with them anyway. */
2023 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2024 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2026 ctf_file_t
*dst
= dst_fp
;
2029 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2032 if ((dmd
->dmd_type
=
2033 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2034 proc_tracking_fp
)) == CTF_ERR
)
2036 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2041 dmd
->dmd_type
= memb_type
;
2045 return CTF_ERR
; /* errno is set for us. */
2050 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2051 && dst_kind
!= CTF_K_FORWARD
)
2053 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2054 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2056 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2057 "members differ, see above\n", name
, dst_type
);
2058 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2063 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2064 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2065 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2066 return CTF_ERR
; /* errno is set for us */
2071 if (dst_type
== CTF_ERR
)
2072 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2076 src_type
= ctf_type_reference (src_fp
, src_type
);
2077 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2080 if (src_type
== CTF_ERR
)
2081 return CTF_ERR
; /* errno is set for us. */
2083 /* If dst_type is not CTF_ERR at this point, we should check if
2084 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2085 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2086 that vary based on things like if 32-bit then pid_t is int otherwise
2087 long. We therefore omit this check and assume that if the identically
2088 named typedef already exists in dst_fp, it is correct or
2091 if (dst_type
== CTF_ERR
)
2092 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2097 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2100 if (dst_type
!= CTF_ERR
)
2101 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2106 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2110 if (!src_fp
->ctf_add_processing
)
2111 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2112 ctf_hash_eq_integer
,
2115 /* We store the hash on the source, because it contains only source type IDs:
2116 but callers will invariably expect errors to appear on the dest. */
2117 if (!src_fp
->ctf_add_processing
)
2118 return (ctf_set_errno (dst_fp
, ENOMEM
));
2120 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2121 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2126 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2128 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2130 const unsigned char *buf
;
2134 resid
= sizeof (ctf_header_t
);
2135 buf
= (unsigned char *) fp
->ctf_header
;
2138 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2139 return (ctf_set_errno (fp
, errno
));
2144 resid
= fp
->ctf_size
;
2148 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2149 return (ctf_set_errno (fp
, errno
));
2157 /* Compress the specified CTF data stream and write it to the specified file
2160 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2165 ctf_header_t
*hp
= &h
;
2166 ssize_t header_len
= sizeof (ctf_header_t
);
2167 ssize_t compress_len
;
2172 if (ctf_serialize (fp
) < 0)
2173 return -1; /* errno is set for us. */
2175 memcpy (hp
, fp
->ctf_header
, header_len
);
2176 hp
->cth_flags
|= CTF_F_COMPRESS
;
2177 compress_len
= compressBound (fp
->ctf_size
);
2179 if ((buf
= malloc (compress_len
)) == NULL
)
2180 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2182 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2183 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2185 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2186 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2190 while (header_len
> 0)
2192 if ((len
= write (fd
, hp
, header_len
)) < 0)
2194 err
= ctf_set_errno (fp
, errno
);
2202 while (compress_len
> 0)
2204 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2206 err
= ctf_set_errno (fp
, errno
);
2209 compress_len
-= len
;
2218 /* Optionally compress the specified CTF data stream and return it as a new
2219 dynamically-allocated string. */
2221 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2226 ssize_t header_len
= sizeof (ctf_header_t
);
2227 ssize_t compress_len
;
2230 if (ctf_serialize (fp
) < 0)
2231 return NULL
; /* errno is set for us. */
2233 compress_len
= compressBound (fp
->ctf_size
);
2234 if (fp
->ctf_size
< threshold
)
2235 compress_len
= fp
->ctf_size
;
2236 if ((buf
= malloc (compress_len
2237 + sizeof (struct ctf_header
))) == NULL
)
2239 ctf_set_errno (fp
, ENOMEM
);
2243 hp
= (ctf_header_t
*) buf
;
2244 memcpy (hp
, fp
->ctf_header
, header_len
);
2245 bp
= buf
+ sizeof (struct ctf_header
);
2246 *size
= sizeof (struct ctf_header
);
2248 if (fp
->ctf_size
< threshold
)
2250 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2251 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2252 *size
+= fp
->ctf_size
;
2256 hp
->cth_flags
|= CTF_F_COMPRESS
;
2257 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2258 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2260 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2261 ctf_set_errno (fp
, ECTF_COMPRESS
);
2265 *size
+= compress_len
;
2270 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2272 ctf_write (ctf_file_t
*fp
, int fd
)
2274 const unsigned char *buf
;
2278 if (ctf_serialize (fp
) < 0)
2279 return -1; /* errno is set for us. */
2281 resid
= sizeof (ctf_header_t
);
2282 buf
= (unsigned char *) fp
->ctf_header
;
2285 if ((len
= write (fd
, buf
, resid
)) <= 0)
2286 return (ctf_set_errno (fp
, errno
));
2291 resid
= fp
->ctf_size
;
2295 if ((len
= write (fd
, buf
, resid
)) <= 0)
2296 return (ctf_set_errno (fp
, errno
));