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
));
520 nfp
->ctf_parent
= fp
->ctf_parent
;
521 nfp
->ctf_parent_unreffed
= fp
->ctf_parent_unreffed
;
522 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
523 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
524 if (nfp
->ctf_dynbase
== NULL
)
525 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
526 nfp
->ctf_dthash
= fp
->ctf_dthash
;
527 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
528 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
529 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
530 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
531 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
532 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
533 nfp
->ctf_specific
= fp
->ctf_specific
;
534 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
535 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
536 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
537 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
538 nfp
->ctf_errs_warnings
= fp
->ctf_errs_warnings
;
539 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
540 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
541 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
542 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
543 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
544 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
546 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
548 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
549 nfp
->ctf_structs
= fp
->ctf_structs
;
550 nfp
->ctf_unions
= fp
->ctf_unions
;
551 nfp
->ctf_enums
= fp
->ctf_enums
;
552 nfp
->ctf_names
= fp
->ctf_names
;
554 fp
->ctf_dthash
= NULL
;
555 ctf_str_free_atoms (nfp
);
556 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
557 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
558 fp
->ctf_str_atoms
= NULL
;
559 fp
->ctf_prov_strtab
= NULL
;
560 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
561 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
562 fp
->ctf_add_processing
= NULL
;
563 fp
->ctf_ptrtab
= NULL
;
564 fp
->ctf_link_inputs
= NULL
;
565 fp
->ctf_link_outputs
= NULL
;
566 fp
->ctf_syn_ext_strtab
= NULL
;
567 fp
->ctf_link_cu_mapping
= NULL
;
568 fp
->ctf_link_type_mapping
= NULL
;
569 fp
->ctf_parent_unreffed
= 1;
571 fp
->ctf_dvhash
= NULL
;
572 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
573 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
574 fp
->ctf_structs
.ctn_writable
= NULL
;
575 fp
->ctf_unions
.ctn_writable
= NULL
;
576 fp
->ctf_enums
.ctn_writable
= NULL
;
577 fp
->ctf_names
.ctn_writable
= NULL
;
579 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
580 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
581 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
583 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
584 ctf_file_close (nfp
);
590 ctf_name_table (ctf_file_t
*fp
, int kind
)
595 return &fp
->ctf_structs
;
597 return &fp
->ctf_unions
;
599 return &fp
->ctf_enums
;
601 return &fp
->ctf_names
;
606 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
609 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
612 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
613 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
615 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
616 (char *) name
, (void *) dtd
->dtd_type
) < 0)
618 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
622 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
627 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
629 ctf_dmdef_t
*dmd
, *nmd
;
630 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
631 int name_kind
= kind
;
634 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
641 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
642 dmd
!= NULL
; dmd
= nmd
)
644 if (dmd
->dmd_name
!= NULL
)
645 free (dmd
->dmd_name
);
646 nmd
= ctf_list_next (dmd
);
651 free (dtd
->dtd_u
.dtu_argv
);
654 name_kind
= dtd
->dtd_data
.ctt_type
;
658 if (dtd
->dtd_data
.ctt_name
659 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
660 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
662 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
664 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
667 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
672 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
674 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
678 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
682 if (!(fp
->ctf_flags
& LCTF_RDWR
))
685 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
688 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
690 if ((unsigned long) idx
<= fp
->ctf_typemax
)
691 return ctf_dtd_lookup (fp
, id
);
696 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
698 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
700 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
705 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
707 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
708 free (dvd
->dvd_name
);
710 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
715 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
717 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
720 /* Discard all of the dynamic type definitions and variable definitions that
721 have been added to the container since the last call to ctf_update(). We
722 locate such types by scanning the dtd list and deleting elements that have
723 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
724 by scanning the variable list and deleting elements that have update IDs
725 equal to the current value of the last-update snapshot count (indicating that
726 they were added after the most recent call to ctf_update()). */
728 ctf_discard (ctf_file_t
*fp
)
730 ctf_snapshot_id_t last_update
=
732 fp
->ctf_snapshot_lu
+ 1 };
734 /* Update required? */
735 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
738 return (ctf_rollback (fp
, last_update
));
742 ctf_snapshot (ctf_file_t
*fp
)
744 ctf_snapshot_id_t snapid
;
745 snapid
.dtd_id
= fp
->ctf_typemax
;
746 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
750 /* Like ctf_discard(), only discards everything after a particular ID. */
752 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
754 ctf_dtdef_t
*dtd
, *ntd
;
755 ctf_dvdef_t
*dvd
, *nvd
;
757 if (!(fp
->ctf_flags
& LCTF_RDWR
))
758 return (ctf_set_errno (fp
, ECTF_RDONLY
));
760 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
761 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
763 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
768 ntd
= ctf_list_next (dtd
);
770 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
773 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
774 if (kind
== CTF_K_FORWARD
)
775 kind
= dtd
->dtd_data
.ctt_type
;
777 if (dtd
->dtd_data
.ctt_name
778 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
779 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
781 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
783 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
786 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
787 ctf_dtd_delete (fp
, dtd
);
790 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
792 nvd
= ctf_list_next (dvd
);
794 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
797 ctf_dvd_delete (fp
, dvd
);
800 fp
->ctf_typemax
= id
.dtd_id
;
801 fp
->ctf_snapshots
= id
.snapshot_id
;
803 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
804 fp
->ctf_flags
&= ~LCTF_DIRTY
;
810 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
816 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
817 return (ctf_set_errno (fp
, EINVAL
));
819 if (!(fp
->ctf_flags
& LCTF_RDWR
))
820 return (ctf_set_errno (fp
, ECTF_RDONLY
));
822 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
823 return (ctf_set_errno (fp
, ECTF_FULL
));
825 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
826 return (ctf_set_errno (fp
, ECTF_FULL
));
828 /* Make sure ptrtab always grows to be big enough for all types. */
829 if (ctf_grow_ptrtab (fp
) < 0)
830 return CTF_ERR
; /* errno is set for us. */
832 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
833 return (ctf_set_errno (fp
, EAGAIN
));
835 type
= ++fp
->ctf_typemax
;
836 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
838 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
839 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
840 dtd
->dtd_type
= type
;
842 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
845 return (ctf_set_errno (fp
, EAGAIN
));
848 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
851 return CTF_ERR
; /* errno is set for us. */
853 fp
->ctf_flags
|= LCTF_DIRTY
;
859 /* When encoding integer sizes, we want to convert a byte count in the range
860 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
861 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
877 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
878 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
884 return (ctf_set_errno (fp
, EINVAL
));
886 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
887 return CTF_ERR
; /* errno is set for us. */
889 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
890 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
892 dtd
->dtd_u
.dtu_enc
= *ep
;
898 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
902 ctf_file_t
*tmp
= fp
;
903 int child
= fp
->ctf_flags
& LCTF_CHILD
;
905 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
906 return (ctf_set_errno (fp
, EINVAL
));
908 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
909 return CTF_ERR
; /* errno is set for us. */
911 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
912 return CTF_ERR
; /* errno is set for us. */
914 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
915 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
917 if (kind
!= CTF_K_POINTER
)
920 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
921 type and (if an anonymous typedef node is being pointed at) the type that
922 points at too. Note that ctf_typemax is at this point one higher than we
923 want to check against, because it's just been incremented for the addition
926 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
927 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
929 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
930 && ref_idx
< fp
->ctf_typemax
)
932 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
934 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
937 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
938 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
939 && refref_idx
< fp
->ctf_typemax
)
940 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
947 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
948 const ctf_encoding_t
*ep
)
951 ctf_id_t resolved_ref
= ref
;
954 const ctf_type_t
*tp
;
955 ctf_file_t
*tmp
= fp
;
958 return (ctf_set_errno (fp
, EINVAL
));
960 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
961 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
963 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
964 return (ctf_set_errno (fp
, EINVAL
));
966 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
967 return CTF_ERR
; /* errno is set for us. */
969 /* Make sure we ultimately point to an integral type. We also allow slices to
970 point to the unimplemented type, for now, because the compiler can emit
971 such slices, though they're not very much use. */
973 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
974 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
976 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
979 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
981 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
982 return CTF_ERR
; /* errno is set for us. */
984 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
985 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
987 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
988 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
989 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
995 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
996 const char *name
, const ctf_encoding_t
*ep
)
998 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1002 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1003 const char *name
, const ctf_encoding_t
*ep
)
1005 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1009 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1011 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1015 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1019 ctf_file_t
*tmp
= fp
;
1022 return (ctf_set_errno (fp
, EINVAL
));
1024 if (arp
->ctr_contents
!= 0
1025 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1026 return CTF_ERR
; /* errno is set for us. */
1029 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1030 return CTF_ERR
; /* errno is set for us. */
1032 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1033 return CTF_ERR
; /* errno is set for us. */
1035 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1036 dtd
->dtd_data
.ctt_size
= 0;
1037 dtd
->dtd_u
.dtu_arr
= *arp
;
1043 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1045 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1047 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1048 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1051 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1052 return (ctf_set_errno (fp
, ECTF_BADID
));
1054 fp
->ctf_flags
|= LCTF_DIRTY
;
1055 dtd
->dtd_u
.dtu_arr
= *arp
;
1061 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1062 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1067 uint32_t *vdat
= NULL
;
1068 ctf_file_t
*tmp
= fp
;
1071 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1072 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1073 return (ctf_set_errno (fp
, EINVAL
));
1075 vlen
= ctc
->ctc_argc
;
1076 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1077 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1079 if (ctc
->ctc_return
!= 0
1080 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1081 return CTF_ERR
; /* errno is set for us. */
1083 if (vlen
> CTF_MAX_VLEN
)
1084 return (ctf_set_errno (fp
, EOVERFLOW
));
1086 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1087 return (ctf_set_errno (fp
, EAGAIN
));
1089 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1092 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1095 return CTF_ERR
; /* errno is set for us. */
1097 vdat
[i
] = (uint32_t) argv
[i
];
1100 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1104 return CTF_ERR
; /* errno is set for us. */
1107 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1108 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1110 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1111 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1112 dtd
->dtd_u
.dtu_argv
= vdat
;
1118 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1124 /* Promote root-visible forwards to structs. */
1126 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1128 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1129 dtd
= ctf_dtd_lookup (fp
, type
);
1130 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1132 return CTF_ERR
; /* errno is set for us. */
1134 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1136 if (size
> CTF_MAX_SIZE
)
1138 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1139 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1140 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1143 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1149 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1151 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1155 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1161 /* Promote root-visible forwards to unions. */
1163 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1165 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1166 dtd
= ctf_dtd_lookup (fp
, type
);
1167 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1169 return CTF_ERR
; /* errno is set for us */
1171 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1173 if (size
> CTF_MAX_SIZE
)
1175 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1176 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1177 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1180 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1186 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1188 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1192 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1197 /* Promote root-visible forwards to enums. */
1199 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1201 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1202 dtd
= ctf_dtd_lookup (fp
, type
);
1203 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1205 return CTF_ERR
; /* errno is set for us. */
1207 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1208 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1214 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1215 const ctf_encoding_t
*ep
)
1219 /* First, create the enum if need be, using most of the same machinery as
1220 ctf_add_enum(), to ensure that we do not allow things past that are not
1221 enums or forwards to them. (This includes other slices: you cannot slice a
1222 slice, which would be a useless thing to do anyway.) */
1225 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1229 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1230 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1231 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1233 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1234 return CTF_ERR
; /* errno is set for us. */
1236 /* Now attach a suitable slice to it. */
1238 return ctf_add_slice (fp
, flag
, type
, ep
);
1242 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1248 if (!ctf_forwardable_kind (kind
))
1249 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1251 /* If the type is already defined or exists as a forward tag, just
1252 return the ctf_id_t of the existing definition. */
1255 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1260 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1261 return CTF_ERR
; /* errno is set for us. */
1263 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1264 dtd
->dtd_data
.ctt_type
= kind
;
1270 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1275 ctf_file_t
*tmp
= fp
;
1277 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1278 return (ctf_set_errno (fp
, EINVAL
));
1280 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1281 return CTF_ERR
; /* errno is set for us. */
1283 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1285 return CTF_ERR
; /* errno is set for us. */
1287 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1288 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1294 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1296 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1300 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1302 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1306 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1308 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1312 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1315 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1318 uint32_t kind
, vlen
, root
;
1322 return (ctf_set_errno (fp
, EINVAL
));
1324 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1325 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1328 return (ctf_set_errno (fp
, ECTF_BADID
));
1330 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1331 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1332 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1334 if (kind
!= CTF_K_ENUM
)
1335 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1337 if (vlen
== CTF_MAX_VLEN
)
1338 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1340 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1341 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1343 if (strcmp (dmd
->dmd_name
, name
) == 0)
1344 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1347 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1348 return (ctf_set_errno (fp
, EAGAIN
));
1350 if ((s
= strdup (name
)) == NULL
)
1353 return (ctf_set_errno (fp
, EAGAIN
));
1357 dmd
->dmd_type
= CTF_ERR
;
1358 dmd
->dmd_offset
= 0;
1359 dmd
->dmd_value
= value
;
1361 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1362 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1364 fp
->ctf_flags
|= LCTF_DIRTY
;
1370 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1371 ctf_id_t type
, unsigned long bit_offset
)
1373 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1376 ssize_t msize
, malign
, ssize
;
1377 uint32_t kind
, vlen
, root
;
1380 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1381 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1384 return (ctf_set_errno (fp
, ECTF_BADID
));
1386 if (name
!= NULL
&& name
[0] == '\0')
1389 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1390 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1391 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1393 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1394 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1396 if (vlen
== CTF_MAX_VLEN
)
1397 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1401 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1402 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1404 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1405 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1409 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1410 (malign
= ctf_type_align (fp
, type
)) < 0)
1412 /* The unimplemented type, and any type that resolves to it, has no size
1413 and no alignment: it can correspond to any number of compiler-inserted
1416 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1420 ctf_set_errno (fp
, 0);
1423 return -1; /* errno is set for us. */
1426 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1427 return (ctf_set_errno (fp
, EAGAIN
));
1429 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1432 return (ctf_set_errno (fp
, EAGAIN
));
1436 dmd
->dmd_type
= type
;
1437 dmd
->dmd_value
= -1;
1439 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1441 if (bit_offset
== (unsigned long) - 1)
1443 /* Natural alignment. */
1445 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1446 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1447 size_t off
= lmd
->dmd_offset
;
1449 ctf_encoding_t linfo
;
1452 /* Propagate any error from ctf_type_resolve. If the last member was
1453 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1454 cannot insert right after such a member without explicit offset
1455 specification, because its alignment and size is not known. */
1456 if (ltype
== CTF_ERR
)
1459 return -1; /* errno is set for us. */
1462 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1463 off
+= linfo
.cte_bits
;
1464 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1465 off
+= lsize
* CHAR_BIT
;
1467 /* Round up the offset of the end of the last member to
1468 the next byte boundary, convert 'off' to bytes, and
1469 then round it up again to the next multiple of the
1470 alignment required by the new member. Finally,
1471 convert back to bits and store the result in
1472 dmd_offset. Technically we could do more efficient
1473 packing if the new member is a bit-field, but we're
1474 the "compiler" and ANSI says we can do as we choose. */
1476 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1477 off
= roundup (off
, MAX (malign
, 1));
1478 dmd
->dmd_offset
= off
* CHAR_BIT
;
1479 ssize
= off
+ msize
;
1483 /* Specified offset in bits. */
1485 dmd
->dmd_offset
= bit_offset
;
1486 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1487 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1492 dmd
->dmd_offset
= 0;
1493 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1494 ssize
= MAX (ssize
, msize
);
1497 if ((size_t) ssize
> CTF_MAX_SIZE
)
1499 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1500 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1501 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1504 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1506 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1507 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1509 fp
->ctf_flags
|= LCTF_DIRTY
;
1514 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1515 ctf_id_t type
, unsigned long bit_offset
,
1516 const ctf_encoding_t encoding
)
1518 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1519 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1522 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1523 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1525 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1526 return -1; /* errno is set for us. */
1528 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1532 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1535 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1539 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1542 ctf_file_t
*tmp
= fp
;
1544 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1545 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1547 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1548 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1550 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1551 return -1; /* errno is set for us. */
1553 /* Make sure this type is representable. */
1554 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1555 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1558 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1559 return (ctf_set_errno (fp
, EAGAIN
));
1561 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1564 return (ctf_set_errno (fp
, EAGAIN
));
1566 dvd
->dvd_type
= ref
;
1567 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1569 if (ctf_dvd_insert (fp
, dvd
) < 0)
1571 free (dvd
->dvd_name
);
1573 return -1; /* errno is set for us. */
1576 fp
->ctf_flags
|= LCTF_DIRTY
;
1581 enumcmp (const char *name
, int value
, void *arg
)
1583 ctf_bundle_t
*ctb
= arg
;
1586 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1588 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1589 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1592 if (value
!= bvalue
)
1594 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1602 enumadd (const char *name
, int value
, void *arg
)
1604 ctf_bundle_t
*ctb
= arg
;
1606 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1611 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1614 ctf_bundle_t
*ctb
= arg
;
1617 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1622 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1624 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1625 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1628 if (ctm
.ctm_offset
!= offset
)
1630 ctf_dprintf ("Conflict due to member %s offset change: "
1631 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1638 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1640 ctf_bundle_t
*ctb
= arg
;
1644 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1645 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1647 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1650 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1653 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1654 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1656 dmd
->dmd_type
= type
;
1657 dmd
->dmd_offset
= offset
;
1658 dmd
->dmd_value
= -1;
1660 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1662 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1666 /* The ctf_add_type routine is used to copy a type from a source CTF container
1667 to a dynamic destination container. This routine operates recursively by
1668 following the source type's links and embedded member types. If the
1669 destination container already contains a named type which has the same
1670 attributes, then we succeed and return this type but no changes occur. */
1672 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1673 ctf_file_t
*proc_tracking_fp
)
1675 ctf_id_t dst_type
= CTF_ERR
;
1676 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1677 ctf_file_t
*tmp_fp
= dst_fp
;
1681 uint32_t kind
, forward_kind
, flag
, vlen
;
1683 const ctf_type_t
*src_tp
, *dst_tp
;
1684 ctf_bundle_t src
, dst
;
1685 ctf_encoding_t src_en
, dst_en
;
1686 ctf_arinfo_t src_ar
, dst_ar
;
1690 ctf_id_t orig_src_type
= src_type
;
1692 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1693 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1695 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1696 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1698 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1699 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1700 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1702 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1703 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1704 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1705 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1707 /* If this is a type we are currently in the middle of adding, hand it
1708 straight back. (This lets us handle self-referential structures without
1709 considering forwards and empty structures the same as their completed
1712 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1716 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1717 (void *) (uintptr_t) src_type
))
1720 /* If this type has already been added from this container, and is the same
1721 kind and (if a struct or union) has the same number of members, hand it
1724 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1726 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1727 || kind
== CTF_K_ENUM
)
1729 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1730 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1738 forward_kind
= kind
;
1739 if (kind
== CTF_K_FORWARD
)
1740 forward_kind
= src_tp
->ctt_type
;
1742 /* If the source type has a name and is a root type (visible at the
1743 top-level scope), lookup the name in the destination container and
1744 verify that it is of the same kind before we do anything else. */
1746 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1747 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1750 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1753 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1754 unless dst_type is a forward declaration and src_type is a struct,
1755 union, or enum (i.e. the definition of the previous forward decl).
1757 We also allow addition in the opposite order (addition of a forward when a
1758 struct, union, or enum already exists), which is a NOP and returns the
1759 already-present struct, union, or enum. */
1761 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1763 if (kind
== CTF_K_FORWARD
1764 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1765 || dst_kind
== CTF_K_UNION
))
1767 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1771 if (dst_kind
!= CTF_K_FORWARD
1772 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1773 && kind
!= CTF_K_UNION
))
1775 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1776 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1777 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1781 /* We take special action for an integer, float, or slice since it is
1782 described not only by its name but also its encoding. For integers,
1783 bit-fields exploit this degeneracy. */
1785 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1787 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1788 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1790 if (dst_type
!= CTF_ERR
)
1792 ctf_file_t
*fp
= dst_fp
;
1794 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1797 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1798 return CTF_ERR
; /* errno set for us. */
1800 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1802 /* The type that we found in the hash is also root-visible. If
1803 the two types match then use the existing one; otherwise,
1804 declare a conflict. Note: slices are not certain to match
1805 even if there is no conflict: we must check the contained type
1808 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1810 if (kind
!= CTF_K_SLICE
)
1812 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1818 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1823 /* We found a non-root-visible type in the hash. If its encoding
1824 is the same, we can reuse it, unless it is a slice. */
1826 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1828 if (kind
!= CTF_K_SLICE
)
1830 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1838 src
.ctb_file
= src_fp
;
1839 src
.ctb_type
= src_type
;
1842 dst
.ctb_file
= dst_fp
;
1843 dst
.ctb_type
= dst_type
;
1846 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1847 a new type with the same properties as src_type to dst_fp. If dst_type is
1848 not CTF_ERR, then we verify that dst_type has the same attributes as
1849 src_type. We recurse for embedded references. Before we start, we note
1850 that we are processing this type, to prevent infinite recursion: we do not
1851 re-process any type that appears in this list. The list is emptied
1852 wholesale at the end of processing everything in this recursive stack. */
1854 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1855 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1856 return ctf_set_errno (dst_fp
, ENOMEM
);
1861 /* If we found a match we will have either returned it or declared a
1863 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1867 /* If we found a match we will have either returned it or declared a
1869 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1873 /* We have checked for conflicting encodings: now try to add the
1875 src_type
= ctf_type_reference (src_fp
, src_type
);
1876 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1879 if (src_type
== CTF_ERR
)
1880 return CTF_ERR
; /* errno is set for us. */
1882 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1886 case CTF_K_VOLATILE
:
1888 case CTF_K_RESTRICT
:
1889 src_type
= ctf_type_reference (src_fp
, src_type
);
1890 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1893 if (src_type
== CTF_ERR
)
1894 return CTF_ERR
; /* errno is set for us. */
1896 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1900 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1901 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1903 src_ar
.ctr_contents
=
1904 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1906 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1909 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1911 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1912 return CTF_ERR
; /* errno is set for us. */
1914 if (dst_type
!= CTF_ERR
)
1916 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1917 return CTF_ERR
; /* errno is set for us. */
1919 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1921 ctf_dprintf ("Conflict for type %s against ID %lx: "
1922 "array info differs, old %lx/%lx/%x; "
1923 "new: %lx/%lx/%x\n", name
, dst_type
,
1924 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1925 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1926 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1927 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1931 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1934 case CTF_K_FUNCTION
:
1935 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1941 if (ctc
.ctc_return
== CTF_ERR
)
1942 return CTF_ERR
; /* errno is set for us. */
1944 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1956 /* Technically to match a struct or union we need to check both
1957 ways (src members vs. dst, dst members vs. src) but we make
1958 this more optimal by only checking src vs. dst and comparing
1959 the total size of the structure (which we must do anyway)
1960 which covers the possibility of dst members not in src.
1961 This optimization can be defeated for unions, but is so
1962 pathological as to render it irrelevant for our purposes. */
1964 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1965 && dst_kind
!= CTF_K_FORWARD
)
1967 if (ctf_type_size (src_fp
, src_type
) !=
1968 ctf_type_size (dst_fp
, dst_type
))
1970 ctf_dprintf ("Conflict for type %s against ID %lx: "
1971 "union size differs, old %li, new %li\n",
1973 (long) ctf_type_size (src_fp
, src_type
),
1974 (long) ctf_type_size (dst_fp
, dst_type
));
1975 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1978 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1980 ctf_dprintf ("Conflict for type %s against ID %lx: "
1981 "members differ, see above\n", name
, dst_type
);
1982 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1988 /* Unlike the other cases, copying structs and unions is done
1989 manually so as to avoid repeated lookups in ctf_add_member
1990 and to ensure the exact same member offsets as in src_type. */
1992 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1993 if (dst_type
== CTF_ERR
)
1994 return CTF_ERR
; /* errno is set for us. */
1996 dst
.ctb_type
= dst_type
;
1999 /* Pre-emptively add this struct to the type mapping so that
2000 structures that refer to themselves work. */
2001 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2003 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2004 errs
++; /* Increment errs and fail at bottom of case. */
2006 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2007 return CTF_ERR
; /* errno is set for us. */
2009 size
= (size_t) ssize
;
2010 if (size
> CTF_MAX_SIZE
)
2012 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2013 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2014 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2017 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2019 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2021 /* Make a final pass through the members changing each dmd_type (a
2022 src_fp type) to an equivalent type in dst_fp. We pass through all
2023 members, leaving any that fail set to CTF_ERR, unless they fail
2024 because they are marking a member of type not representable in this
2025 version of CTF, in which case we just want to silently omit them:
2026 no consumer can do anything with them anyway. */
2027 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2028 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2030 ctf_file_t
*dst
= dst_fp
;
2033 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2036 if ((dmd
->dmd_type
=
2037 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2038 proc_tracking_fp
)) == CTF_ERR
)
2040 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2045 dmd
->dmd_type
= memb_type
;
2049 return CTF_ERR
; /* errno is set for us. */
2054 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2055 && dst_kind
!= CTF_K_FORWARD
)
2057 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2058 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2060 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2061 "members differ, see above\n", name
, dst_type
);
2062 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2067 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2068 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2069 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2070 return CTF_ERR
; /* errno is set for us */
2075 if (dst_type
== CTF_ERR
)
2076 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2080 src_type
= ctf_type_reference (src_fp
, src_type
);
2081 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2084 if (src_type
== CTF_ERR
)
2085 return CTF_ERR
; /* errno is set for us. */
2087 /* If dst_type is not CTF_ERR at this point, we should check if
2088 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2089 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2090 that vary based on things like if 32-bit then pid_t is int otherwise
2091 long. We therefore omit this check and assume that if the identically
2092 named typedef already exists in dst_fp, it is correct or
2095 if (dst_type
== CTF_ERR
)
2096 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2101 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2104 if (dst_type
!= CTF_ERR
)
2105 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2110 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2114 if (!src_fp
->ctf_add_processing
)
2115 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2116 ctf_hash_eq_integer
,
2119 /* We store the hash on the source, because it contains only source type IDs:
2120 but callers will invariably expect errors to appear on the dest. */
2121 if (!src_fp
->ctf_add_processing
)
2122 return (ctf_set_errno (dst_fp
, ENOMEM
));
2124 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2125 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2130 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2132 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2134 const unsigned char *buf
;
2138 resid
= sizeof (ctf_header_t
);
2139 buf
= (unsigned char *) fp
->ctf_header
;
2142 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2143 return (ctf_set_errno (fp
, errno
));
2148 resid
= fp
->ctf_size
;
2152 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2153 return (ctf_set_errno (fp
, errno
));
2161 /* Compress the specified CTF data stream and write it to the specified file
2164 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2169 ctf_header_t
*hp
= &h
;
2170 ssize_t header_len
= sizeof (ctf_header_t
);
2171 ssize_t compress_len
;
2176 if (ctf_serialize (fp
) < 0)
2177 return -1; /* errno is set for us. */
2179 memcpy (hp
, fp
->ctf_header
, header_len
);
2180 hp
->cth_flags
|= CTF_F_COMPRESS
;
2181 compress_len
= compressBound (fp
->ctf_size
);
2183 if ((buf
= malloc (compress_len
)) == NULL
)
2184 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2186 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2187 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2189 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2190 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2194 while (header_len
> 0)
2196 if ((len
= write (fd
, hp
, header_len
)) < 0)
2198 err
= ctf_set_errno (fp
, errno
);
2206 while (compress_len
> 0)
2208 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2210 err
= ctf_set_errno (fp
, errno
);
2213 compress_len
-= len
;
2222 /* Optionally compress the specified CTF data stream and return it as a new
2223 dynamically-allocated string. */
2225 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2230 ssize_t header_len
= sizeof (ctf_header_t
);
2231 ssize_t compress_len
;
2234 if (ctf_serialize (fp
) < 0)
2235 return NULL
; /* errno is set for us. */
2237 compress_len
= compressBound (fp
->ctf_size
);
2238 if (fp
->ctf_size
< threshold
)
2239 compress_len
= fp
->ctf_size
;
2240 if ((buf
= malloc (compress_len
2241 + sizeof (struct ctf_header
))) == NULL
)
2243 ctf_set_errno (fp
, ENOMEM
);
2247 hp
= (ctf_header_t
*) buf
;
2248 memcpy (hp
, fp
->ctf_header
, header_len
);
2249 bp
= buf
+ sizeof (struct ctf_header
);
2250 *size
= sizeof (struct ctf_header
);
2252 if (fp
->ctf_size
< threshold
)
2254 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2255 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2256 *size
+= fp
->ctf_size
;
2260 hp
->cth_flags
|= CTF_F_COMPRESS
;
2261 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2262 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2264 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2265 ctf_set_errno (fp
, ECTF_COMPRESS
);
2269 *size
+= compress_len
;
2274 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2276 ctf_write (ctf_file_t
*fp
, int fd
)
2278 const unsigned char *buf
;
2282 if (ctf_serialize (fp
) < 0)
2283 return -1; /* errno is set for us. */
2285 resid
= sizeof (ctf_header_t
);
2286 buf
= (unsigned char *) fp
->ctf_header
;
2289 if ((len
= write (fd
, buf
, resid
)) <= 0)
2290 return (ctf_set_errno (fp
, errno
));
2295 resid
= fp
->ctf_size
;
2299 if ((len
= write (fd
, buf
, resid
)) <= 0)
2300 return (ctf_set_errno (fp
, errno
));