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_errs_warnings
= fp
->ctf_errs_warnings
;
538 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
539 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
540 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
541 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
542 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
543 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
545 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
547 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
548 nfp
->ctf_structs
= fp
->ctf_structs
;
549 nfp
->ctf_unions
= fp
->ctf_unions
;
550 nfp
->ctf_enums
= fp
->ctf_enums
;
551 nfp
->ctf_names
= fp
->ctf_names
;
553 fp
->ctf_dthash
= NULL
;
554 ctf_str_free_atoms (nfp
);
555 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
556 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
557 fp
->ctf_str_atoms
= NULL
;
558 fp
->ctf_prov_strtab
= NULL
;
559 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
560 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
561 fp
->ctf_add_processing
= NULL
;
562 fp
->ctf_ptrtab
= NULL
;
563 fp
->ctf_link_inputs
= NULL
;
564 fp
->ctf_link_outputs
= NULL
;
565 fp
->ctf_syn_ext_strtab
= NULL
;
566 fp
->ctf_link_cu_mapping
= NULL
;
567 fp
->ctf_link_type_mapping
= NULL
;
569 fp
->ctf_dvhash
= NULL
;
570 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
571 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
572 fp
->ctf_structs
.ctn_writable
= NULL
;
573 fp
->ctf_unions
.ctn_writable
= NULL
;
574 fp
->ctf_enums
.ctn_writable
= NULL
;
575 fp
->ctf_names
.ctn_writable
= NULL
;
577 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
578 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
579 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
581 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
582 ctf_file_close (nfp
);
588 ctf_name_table (ctf_file_t
*fp
, int kind
)
593 return &fp
->ctf_structs
;
595 return &fp
->ctf_unions
;
597 return &fp
->ctf_enums
;
599 return &fp
->ctf_names
;
604 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
607 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
610 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
611 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
613 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
614 (char *) name
, (void *) dtd
->dtd_type
) < 0)
616 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
620 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
625 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
627 ctf_dmdef_t
*dmd
, *nmd
;
628 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
629 int name_kind
= kind
;
632 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
639 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
640 dmd
!= NULL
; dmd
= nmd
)
642 if (dmd
->dmd_name
!= NULL
)
643 free (dmd
->dmd_name
);
644 nmd
= ctf_list_next (dmd
);
649 free (dtd
->dtd_u
.dtu_argv
);
652 name_kind
= dtd
->dtd_data
.ctt_type
;
656 if (dtd
->dtd_data
.ctt_name
657 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
658 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
660 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
662 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
665 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
670 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
672 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
676 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
680 if (!(fp
->ctf_flags
& LCTF_RDWR
))
683 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
686 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
688 if ((unsigned long) idx
<= fp
->ctf_typemax
)
689 return ctf_dtd_lookup (fp
, id
);
694 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
696 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
698 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
703 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
705 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
706 free (dvd
->dvd_name
);
708 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
713 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
715 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
718 /* Discard all of the dynamic type definitions and variable definitions that
719 have been added to the container since the last call to ctf_update(). We
720 locate such types by scanning the dtd list and deleting elements that have
721 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
722 by scanning the variable list and deleting elements that have update IDs
723 equal to the current value of the last-update snapshot count (indicating that
724 they were added after the most recent call to ctf_update()). */
726 ctf_discard (ctf_file_t
*fp
)
728 ctf_snapshot_id_t last_update
=
730 fp
->ctf_snapshot_lu
+ 1 };
732 /* Update required? */
733 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
736 return (ctf_rollback (fp
, last_update
));
740 ctf_snapshot (ctf_file_t
*fp
)
742 ctf_snapshot_id_t snapid
;
743 snapid
.dtd_id
= fp
->ctf_typemax
;
744 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
748 /* Like ctf_discard(), only discards everything after a particular ID. */
750 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
752 ctf_dtdef_t
*dtd
, *ntd
;
753 ctf_dvdef_t
*dvd
, *nvd
;
755 if (!(fp
->ctf_flags
& LCTF_RDWR
))
756 return (ctf_set_errno (fp
, ECTF_RDONLY
));
758 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
759 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
761 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
766 ntd
= ctf_list_next (dtd
);
768 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
771 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
772 if (kind
== CTF_K_FORWARD
)
773 kind
= dtd
->dtd_data
.ctt_type
;
775 if (dtd
->dtd_data
.ctt_name
776 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
777 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
779 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
781 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
784 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
785 ctf_dtd_delete (fp
, dtd
);
788 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
790 nvd
= ctf_list_next (dvd
);
792 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
795 ctf_dvd_delete (fp
, dvd
);
798 fp
->ctf_typemax
= id
.dtd_id
;
799 fp
->ctf_snapshots
= id
.snapshot_id
;
801 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
802 fp
->ctf_flags
&= ~LCTF_DIRTY
;
808 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
814 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
815 return (ctf_set_errno (fp
, EINVAL
));
817 if (!(fp
->ctf_flags
& LCTF_RDWR
))
818 return (ctf_set_errno (fp
, ECTF_RDONLY
));
820 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
821 return (ctf_set_errno (fp
, ECTF_FULL
));
823 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
824 return (ctf_set_errno (fp
, ECTF_FULL
));
826 /* Make sure ptrtab always grows to be big enough for all types. */
827 if (ctf_grow_ptrtab (fp
) < 0)
828 return CTF_ERR
; /* errno is set for us. */
830 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
831 return (ctf_set_errno (fp
, EAGAIN
));
833 type
= ++fp
->ctf_typemax
;
834 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
836 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
837 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
838 dtd
->dtd_type
= type
;
840 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
843 return (ctf_set_errno (fp
, EAGAIN
));
846 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
849 return CTF_ERR
; /* errno is set for us. */
851 fp
->ctf_flags
|= LCTF_DIRTY
;
857 /* When encoding integer sizes, we want to convert a byte count in the range
858 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
859 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
875 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
876 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
882 return (ctf_set_errno (fp
, EINVAL
));
884 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
885 return CTF_ERR
; /* errno is set for us. */
887 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
888 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
890 dtd
->dtd_u
.dtu_enc
= *ep
;
896 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
900 ctf_file_t
*tmp
= fp
;
901 int child
= fp
->ctf_flags
& LCTF_CHILD
;
903 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
904 return (ctf_set_errno (fp
, EINVAL
));
906 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
907 return CTF_ERR
; /* errno is set for us. */
909 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
910 return CTF_ERR
; /* errno is set for us. */
912 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
913 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
915 if (kind
!= CTF_K_POINTER
)
918 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
919 type and (if an anonymous typedef node is being pointed at) the type that
920 points at too. Note that ctf_typemax is at this point one higher than we
921 want to check against, because it's just been incremented for the addition
924 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
925 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
927 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
928 && ref_idx
< fp
->ctf_typemax
)
930 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
932 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
935 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
936 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
937 && refref_idx
< fp
->ctf_typemax
)
938 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
945 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
946 const ctf_encoding_t
*ep
)
949 ctf_id_t resolved_ref
= ref
;
952 const ctf_type_t
*tp
;
953 ctf_file_t
*tmp
= fp
;
956 return (ctf_set_errno (fp
, EINVAL
));
958 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
959 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
961 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
962 return (ctf_set_errno (fp
, EINVAL
));
964 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
965 return CTF_ERR
; /* errno is set for us. */
967 /* Make sure we ultimately point to an integral type. We also allow slices to
968 point to the unimplemented type, for now, because the compiler can emit
969 such slices, though they're not very much use. */
971 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
972 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
974 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
977 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
979 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
980 return CTF_ERR
; /* errno is set for us. */
982 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
983 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
985 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
986 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
987 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
993 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
994 const char *name
, const ctf_encoding_t
*ep
)
996 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1000 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1001 const char *name
, const ctf_encoding_t
*ep
)
1003 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1007 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1009 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1013 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1017 ctf_file_t
*tmp
= fp
;
1020 return (ctf_set_errno (fp
, EINVAL
));
1022 if (arp
->ctr_contents
!= 0
1023 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1024 return CTF_ERR
; /* errno is set for us. */
1027 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1028 return CTF_ERR
; /* errno is set for us. */
1030 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1031 return CTF_ERR
; /* errno is set for us. */
1033 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1034 dtd
->dtd_data
.ctt_size
= 0;
1035 dtd
->dtd_u
.dtu_arr
= *arp
;
1041 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1043 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1045 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1046 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1049 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1050 return (ctf_set_errno (fp
, ECTF_BADID
));
1052 fp
->ctf_flags
|= LCTF_DIRTY
;
1053 dtd
->dtd_u
.dtu_arr
= *arp
;
1059 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1060 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1065 uint32_t *vdat
= NULL
;
1066 ctf_file_t
*tmp
= fp
;
1069 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1070 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1071 return (ctf_set_errno (fp
, EINVAL
));
1073 vlen
= ctc
->ctc_argc
;
1074 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1075 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1077 if (ctc
->ctc_return
!= 0
1078 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1079 return CTF_ERR
; /* errno is set for us. */
1081 if (vlen
> CTF_MAX_VLEN
)
1082 return (ctf_set_errno (fp
, EOVERFLOW
));
1084 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1085 return (ctf_set_errno (fp
, EAGAIN
));
1087 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1090 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1093 return CTF_ERR
; /* errno is set for us. */
1095 vdat
[i
] = (uint32_t) argv
[i
];
1098 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1102 return CTF_ERR
; /* errno is set for us. */
1105 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1106 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1108 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1109 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1110 dtd
->dtd_u
.dtu_argv
= vdat
;
1116 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1122 /* Promote root-visible forwards to structs. */
1124 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1126 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1127 dtd
= ctf_dtd_lookup (fp
, type
);
1128 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1130 return CTF_ERR
; /* errno is set for us. */
1132 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1134 if (size
> CTF_MAX_SIZE
)
1136 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1137 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1138 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1141 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1147 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1149 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1153 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1159 /* Promote root-visible forwards to unions. */
1161 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1163 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1164 dtd
= ctf_dtd_lookup (fp
, type
);
1165 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1167 return CTF_ERR
; /* errno is set for us */
1169 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1171 if (size
> CTF_MAX_SIZE
)
1173 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1174 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1175 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1178 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1184 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1186 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1190 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1195 /* Promote root-visible forwards to enums. */
1197 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1199 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1200 dtd
= ctf_dtd_lookup (fp
, type
);
1201 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1203 return CTF_ERR
; /* errno is set for us. */
1205 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1206 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1212 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1213 const ctf_encoding_t
*ep
)
1217 /* First, create the enum if need be, using most of the same machinery as
1218 ctf_add_enum(), to ensure that we do not allow things past that are not
1219 enums or forwards to them. (This includes other slices: you cannot slice a
1220 slice, which would be a useless thing to do anyway.) */
1223 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1227 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1228 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1229 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1231 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1232 return CTF_ERR
; /* errno is set for us. */
1234 /* Now attach a suitable slice to it. */
1236 return ctf_add_slice (fp
, flag
, type
, ep
);
1240 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1246 if (!ctf_forwardable_kind (kind
))
1247 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1249 /* If the type is already defined or exists as a forward tag, just
1250 return the ctf_id_t of the existing definition. */
1253 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1258 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1259 return CTF_ERR
; /* errno is set for us. */
1261 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1262 dtd
->dtd_data
.ctt_type
= kind
;
1268 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1273 ctf_file_t
*tmp
= fp
;
1275 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1276 return (ctf_set_errno (fp
, EINVAL
));
1278 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1279 return CTF_ERR
; /* errno is set for us. */
1281 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1283 return CTF_ERR
; /* errno is set for us. */
1285 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1286 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1292 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1294 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1298 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1300 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1304 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1306 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1310 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1313 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1316 uint32_t kind
, vlen
, root
;
1320 return (ctf_set_errno (fp
, EINVAL
));
1322 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1323 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1326 return (ctf_set_errno (fp
, ECTF_BADID
));
1328 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1329 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1330 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1332 if (kind
!= CTF_K_ENUM
)
1333 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1335 if (vlen
== CTF_MAX_VLEN
)
1336 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1338 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1339 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1341 if (strcmp (dmd
->dmd_name
, name
) == 0)
1342 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1345 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1346 return (ctf_set_errno (fp
, EAGAIN
));
1348 if ((s
= strdup (name
)) == NULL
)
1351 return (ctf_set_errno (fp
, EAGAIN
));
1355 dmd
->dmd_type
= CTF_ERR
;
1356 dmd
->dmd_offset
= 0;
1357 dmd
->dmd_value
= value
;
1359 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1360 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1362 fp
->ctf_flags
|= LCTF_DIRTY
;
1368 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1369 ctf_id_t type
, unsigned long bit_offset
)
1371 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1374 ssize_t msize
, malign
, ssize
;
1375 uint32_t kind
, vlen
, root
;
1378 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1379 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1382 return (ctf_set_errno (fp
, ECTF_BADID
));
1384 if (name
!= NULL
&& name
[0] == '\0')
1387 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1388 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1389 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1391 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1392 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1394 if (vlen
== CTF_MAX_VLEN
)
1395 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1399 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1400 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1402 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1403 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1407 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1408 (malign
= ctf_type_align (fp
, type
)) < 0)
1410 /* The unimplemented type, and any type that resolves to it, has no size
1411 and no alignment: it can correspond to any number of compiler-inserted
1414 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1418 ctf_set_errno (fp
, 0);
1421 return -1; /* errno is set for us. */
1424 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1425 return (ctf_set_errno (fp
, EAGAIN
));
1427 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1430 return (ctf_set_errno (fp
, EAGAIN
));
1434 dmd
->dmd_type
= type
;
1435 dmd
->dmd_value
= -1;
1437 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1439 if (bit_offset
== (unsigned long) - 1)
1441 /* Natural alignment. */
1443 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1444 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1445 size_t off
= lmd
->dmd_offset
;
1447 ctf_encoding_t linfo
;
1450 /* Propagate any error from ctf_type_resolve. If the last member was
1451 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1452 cannot insert right after such a member without explicit offset
1453 specification, because its alignment and size is not known. */
1454 if (ltype
== CTF_ERR
)
1457 return -1; /* errno is set for us. */
1460 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1461 off
+= linfo
.cte_bits
;
1462 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1463 off
+= lsize
* CHAR_BIT
;
1465 /* Round up the offset of the end of the last member to
1466 the next byte boundary, convert 'off' to bytes, and
1467 then round it up again to the next multiple of the
1468 alignment required by the new member. Finally,
1469 convert back to bits and store the result in
1470 dmd_offset. Technically we could do more efficient
1471 packing if the new member is a bit-field, but we're
1472 the "compiler" and ANSI says we can do as we choose. */
1474 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1475 off
= roundup (off
, MAX (malign
, 1));
1476 dmd
->dmd_offset
= off
* CHAR_BIT
;
1477 ssize
= off
+ msize
;
1481 /* Specified offset in bits. */
1483 dmd
->dmd_offset
= bit_offset
;
1484 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1485 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1490 dmd
->dmd_offset
= 0;
1491 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1492 ssize
= MAX (ssize
, msize
);
1495 if ((size_t) ssize
> CTF_MAX_SIZE
)
1497 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1498 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1499 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1502 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1504 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1505 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1507 fp
->ctf_flags
|= LCTF_DIRTY
;
1512 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1513 ctf_id_t type
, unsigned long bit_offset
,
1514 const ctf_encoding_t encoding
)
1516 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1517 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1520 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1521 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1523 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1524 return -1; /* errno is set for us. */
1526 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1530 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1533 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1537 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1540 ctf_file_t
*tmp
= fp
;
1542 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1543 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1545 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1546 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1548 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1549 return -1; /* errno is set for us. */
1551 /* Make sure this type is representable. */
1552 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1553 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1556 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1557 return (ctf_set_errno (fp
, EAGAIN
));
1559 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1562 return (ctf_set_errno (fp
, EAGAIN
));
1564 dvd
->dvd_type
= ref
;
1565 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1567 if (ctf_dvd_insert (fp
, dvd
) < 0)
1569 free (dvd
->dvd_name
);
1571 return -1; /* errno is set for us. */
1574 fp
->ctf_flags
|= LCTF_DIRTY
;
1579 enumcmp (const char *name
, int value
, void *arg
)
1581 ctf_bundle_t
*ctb
= arg
;
1584 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1586 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1587 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1590 if (value
!= bvalue
)
1592 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1600 enumadd (const char *name
, int value
, void *arg
)
1602 ctf_bundle_t
*ctb
= arg
;
1604 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1609 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1612 ctf_bundle_t
*ctb
= arg
;
1615 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1620 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1622 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1623 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1626 if (ctm
.ctm_offset
!= offset
)
1628 ctf_dprintf ("Conflict due to member %s offset change: "
1629 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1636 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1638 ctf_bundle_t
*ctb
= arg
;
1642 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1643 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1645 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1648 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1651 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1652 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1654 dmd
->dmd_type
= type
;
1655 dmd
->dmd_offset
= offset
;
1656 dmd
->dmd_value
= -1;
1658 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1660 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1664 /* The ctf_add_type routine is used to copy a type from a source CTF container
1665 to a dynamic destination container. This routine operates recursively by
1666 following the source type's links and embedded member types. If the
1667 destination container already contains a named type which has the same
1668 attributes, then we succeed and return this type but no changes occur. */
1670 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1671 ctf_file_t
*proc_tracking_fp
)
1673 ctf_id_t dst_type
= CTF_ERR
;
1674 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1675 ctf_file_t
*tmp_fp
= dst_fp
;
1679 uint32_t kind
, forward_kind
, flag
, vlen
;
1681 const ctf_type_t
*src_tp
, *dst_tp
;
1682 ctf_bundle_t src
, dst
;
1683 ctf_encoding_t src_en
, dst_en
;
1684 ctf_arinfo_t src_ar
, dst_ar
;
1688 ctf_id_t orig_src_type
= src_type
;
1690 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1691 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1693 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1694 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1696 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1697 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1698 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1700 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1701 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1702 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1703 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1705 /* If this is a type we are currently in the middle of adding, hand it
1706 straight back. (This lets us handle self-referential structures without
1707 considering forwards and empty structures the same as their completed
1710 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1714 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1715 (void *) (uintptr_t) src_type
))
1718 /* If this type has already been added from this container, and is the same
1719 kind and (if a struct or union) has the same number of members, hand it
1722 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1724 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1725 || kind
== CTF_K_ENUM
)
1727 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1728 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1736 forward_kind
= kind
;
1737 if (kind
== CTF_K_FORWARD
)
1738 forward_kind
= src_tp
->ctt_type
;
1740 /* If the source type has a name and is a root type (visible at the
1741 top-level scope), lookup the name in the destination container and
1742 verify that it is of the same kind before we do anything else. */
1744 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1745 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1748 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1751 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1752 unless dst_type is a forward declaration and src_type is a struct,
1753 union, or enum (i.e. the definition of the previous forward decl).
1755 We also allow addition in the opposite order (addition of a forward when a
1756 struct, union, or enum already exists), which is a NOP and returns the
1757 already-present struct, union, or enum. */
1759 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1761 if (kind
== CTF_K_FORWARD
1762 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1763 || dst_kind
== CTF_K_UNION
))
1765 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1769 if (dst_kind
!= CTF_K_FORWARD
1770 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1771 && kind
!= CTF_K_UNION
))
1773 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1774 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1775 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1779 /* We take special action for an integer, float, or slice since it is
1780 described not only by its name but also its encoding. For integers,
1781 bit-fields exploit this degeneracy. */
1783 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1785 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1786 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1788 if (dst_type
!= CTF_ERR
)
1790 ctf_file_t
*fp
= dst_fp
;
1792 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1795 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1796 return CTF_ERR
; /* errno set for us. */
1798 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1800 /* The type that we found in the hash is also root-visible. If
1801 the two types match then use the existing one; otherwise,
1802 declare a conflict. Note: slices are not certain to match
1803 even if there is no conflict: we must check the contained type
1806 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1808 if (kind
!= CTF_K_SLICE
)
1810 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1816 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1821 /* We found a non-root-visible type in the hash. If its encoding
1822 is the same, we can reuse it, unless it is a slice. */
1824 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1826 if (kind
!= CTF_K_SLICE
)
1828 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1836 src
.ctb_file
= src_fp
;
1837 src
.ctb_type
= src_type
;
1840 dst
.ctb_file
= dst_fp
;
1841 dst
.ctb_type
= dst_type
;
1844 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1845 a new type with the same properties as src_type to dst_fp. If dst_type is
1846 not CTF_ERR, then we verify that dst_type has the same attributes as
1847 src_type. We recurse for embedded references. Before we start, we note
1848 that we are processing this type, to prevent infinite recursion: we do not
1849 re-process any type that appears in this list. The list is emptied
1850 wholesale at the end of processing everything in this recursive stack. */
1852 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1853 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1854 return ctf_set_errno (dst_fp
, ENOMEM
);
1859 /* If we found a match we will have either returned it or declared a
1861 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1865 /* If we found a match we will have either returned it or declared a
1867 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1871 /* We have checked for conflicting encodings: now try to add the
1873 src_type
= ctf_type_reference (src_fp
, src_type
);
1874 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1877 if (src_type
== CTF_ERR
)
1878 return CTF_ERR
; /* errno is set for us. */
1880 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1884 case CTF_K_VOLATILE
:
1886 case CTF_K_RESTRICT
:
1887 src_type
= ctf_type_reference (src_fp
, src_type
);
1888 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1891 if (src_type
== CTF_ERR
)
1892 return CTF_ERR
; /* errno is set for us. */
1894 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1898 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1899 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1901 src_ar
.ctr_contents
=
1902 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1904 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1907 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1909 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1910 return CTF_ERR
; /* errno is set for us. */
1912 if (dst_type
!= CTF_ERR
)
1914 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1915 return CTF_ERR
; /* errno is set for us. */
1917 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1919 ctf_dprintf ("Conflict for type %s against ID %lx: "
1920 "array info differs, old %lx/%lx/%x; "
1921 "new: %lx/%lx/%x\n", name
, dst_type
,
1922 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1923 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1924 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1925 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1929 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1932 case CTF_K_FUNCTION
:
1933 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1939 if (ctc
.ctc_return
== CTF_ERR
)
1940 return CTF_ERR
; /* errno is set for us. */
1942 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1954 /* Technically to match a struct or union we need to check both
1955 ways (src members vs. dst, dst members vs. src) but we make
1956 this more optimal by only checking src vs. dst and comparing
1957 the total size of the structure (which we must do anyway)
1958 which covers the possibility of dst members not in src.
1959 This optimization can be defeated for unions, but is so
1960 pathological as to render it irrelevant for our purposes. */
1962 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1963 && dst_kind
!= CTF_K_FORWARD
)
1965 if (ctf_type_size (src_fp
, src_type
) !=
1966 ctf_type_size (dst_fp
, dst_type
))
1968 ctf_dprintf ("Conflict for type %s against ID %lx: "
1969 "union size differs, old %li, new %li\n",
1971 (long) ctf_type_size (src_fp
, src_type
),
1972 (long) ctf_type_size (dst_fp
, dst_type
));
1973 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1976 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1978 ctf_dprintf ("Conflict for type %s against ID %lx: "
1979 "members differ, see above\n", name
, dst_type
);
1980 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1986 /* Unlike the other cases, copying structs and unions is done
1987 manually so as to avoid repeated lookups in ctf_add_member
1988 and to ensure the exact same member offsets as in src_type. */
1990 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1991 if (dst_type
== CTF_ERR
)
1992 return CTF_ERR
; /* errno is set for us. */
1994 dst
.ctb_type
= dst_type
;
1997 /* Pre-emptively add this struct to the type mapping so that
1998 structures that refer to themselves work. */
1999 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2001 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2002 errs
++; /* Increment errs and fail at bottom of case. */
2004 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2005 return CTF_ERR
; /* errno is set for us. */
2007 size
= (size_t) ssize
;
2008 if (size
> CTF_MAX_SIZE
)
2010 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2011 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2012 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2015 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2017 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2019 /* Make a final pass through the members changing each dmd_type (a
2020 src_fp type) to an equivalent type in dst_fp. We pass through all
2021 members, leaving any that fail set to CTF_ERR, unless they fail
2022 because they are marking a member of type not representable in this
2023 version of CTF, in which case we just want to silently omit them:
2024 no consumer can do anything with them anyway. */
2025 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2026 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2028 ctf_file_t
*dst
= dst_fp
;
2031 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2034 if ((dmd
->dmd_type
=
2035 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2036 proc_tracking_fp
)) == CTF_ERR
)
2038 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2043 dmd
->dmd_type
= memb_type
;
2047 return CTF_ERR
; /* errno is set for us. */
2052 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2053 && dst_kind
!= CTF_K_FORWARD
)
2055 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2056 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2058 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2059 "members differ, see above\n", name
, dst_type
);
2060 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2065 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2066 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2067 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2068 return CTF_ERR
; /* errno is set for us */
2073 if (dst_type
== CTF_ERR
)
2074 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2078 src_type
= ctf_type_reference (src_fp
, src_type
);
2079 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2082 if (src_type
== CTF_ERR
)
2083 return CTF_ERR
; /* errno is set for us. */
2085 /* If dst_type is not CTF_ERR at this point, we should check if
2086 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2087 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2088 that vary based on things like if 32-bit then pid_t is int otherwise
2089 long. We therefore omit this check and assume that if the identically
2090 named typedef already exists in dst_fp, it is correct or
2093 if (dst_type
== CTF_ERR
)
2094 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2099 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2102 if (dst_type
!= CTF_ERR
)
2103 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2108 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2112 if (!src_fp
->ctf_add_processing
)
2113 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2114 ctf_hash_eq_integer
,
2117 /* We store the hash on the source, because it contains only source type IDs:
2118 but callers will invariably expect errors to appear on the dest. */
2119 if (!src_fp
->ctf_add_processing
)
2120 return (ctf_set_errno (dst_fp
, ENOMEM
));
2122 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2123 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2128 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2130 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2132 const unsigned char *buf
;
2136 resid
= sizeof (ctf_header_t
);
2137 buf
= (unsigned char *) fp
->ctf_header
;
2140 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2141 return (ctf_set_errno (fp
, errno
));
2146 resid
= fp
->ctf_size
;
2150 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2151 return (ctf_set_errno (fp
, errno
));
2159 /* Compress the specified CTF data stream and write it to the specified file
2162 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2167 ctf_header_t
*hp
= &h
;
2168 ssize_t header_len
= sizeof (ctf_header_t
);
2169 ssize_t compress_len
;
2174 if (ctf_serialize (fp
) < 0)
2175 return -1; /* errno is set for us. */
2177 memcpy (hp
, fp
->ctf_header
, header_len
);
2178 hp
->cth_flags
|= CTF_F_COMPRESS
;
2179 compress_len
= compressBound (fp
->ctf_size
);
2181 if ((buf
= malloc (compress_len
)) == NULL
)
2182 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2184 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2185 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2187 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2188 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2192 while (header_len
> 0)
2194 if ((len
= write (fd
, hp
, header_len
)) < 0)
2196 err
= ctf_set_errno (fp
, errno
);
2204 while (compress_len
> 0)
2206 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2208 err
= ctf_set_errno (fp
, errno
);
2211 compress_len
-= len
;
2220 /* Optionally compress the specified CTF data stream and return it as a new
2221 dynamically-allocated string. */
2223 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2228 ssize_t header_len
= sizeof (ctf_header_t
);
2229 ssize_t compress_len
;
2232 if (ctf_serialize (fp
) < 0)
2233 return NULL
; /* errno is set for us. */
2235 compress_len
= compressBound (fp
->ctf_size
);
2236 if (fp
->ctf_size
< threshold
)
2237 compress_len
= fp
->ctf_size
;
2238 if ((buf
= malloc (compress_len
2239 + sizeof (struct ctf_header
))) == NULL
)
2241 ctf_set_errno (fp
, ENOMEM
);
2245 hp
= (ctf_header_t
*) buf
;
2246 memcpy (hp
, fp
->ctf_header
, header_len
);
2247 bp
= buf
+ sizeof (struct ctf_header
);
2248 *size
= sizeof (struct ctf_header
);
2250 if (fp
->ctf_size
< threshold
)
2252 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2253 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2254 *size
+= fp
->ctf_size
;
2258 hp
->cth_flags
|= CTF_F_COMPRESS
;
2259 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2260 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2262 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2263 ctf_set_errno (fp
, ECTF_COMPRESS
);
2267 *size
+= compress_len
;
2272 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2274 ctf_write (ctf_file_t
*fp
, int fd
)
2276 const unsigned char *buf
;
2280 if (ctf_serialize (fp
) < 0)
2281 return -1; /* errno is set for us. */
2283 resid
= sizeof (ctf_header_t
);
2284 buf
= (unsigned char *) fp
->ctf_header
;
2287 if ((len
= write (fd
, buf
, resid
)) <= 0)
2288 return (ctf_set_errno (fp
, errno
));
2293 resid
= fp
->ctf_size
;
2297 if ((len
= write (fd
, buf
, resid
)) <= 0)
2298 return (ctf_set_errno (fp
, errno
));