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_in_cu_mapping
= fp
->ctf_link_in_cu_mapping
;
542 nfp
->ctf_link_out_cu_mapping
= fp
->ctf_link_out_cu_mapping
;
543 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
544 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
545 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
546 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
548 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
550 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
551 nfp
->ctf_structs
= fp
->ctf_structs
;
552 nfp
->ctf_unions
= fp
->ctf_unions
;
553 nfp
->ctf_enums
= fp
->ctf_enums
;
554 nfp
->ctf_names
= fp
->ctf_names
;
556 fp
->ctf_dthash
= NULL
;
557 ctf_str_free_atoms (nfp
);
558 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
559 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
560 fp
->ctf_str_atoms
= NULL
;
561 fp
->ctf_prov_strtab
= NULL
;
562 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
563 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
564 fp
->ctf_add_processing
= NULL
;
565 fp
->ctf_ptrtab
= NULL
;
566 fp
->ctf_link_inputs
= NULL
;
567 fp
->ctf_link_outputs
= NULL
;
568 fp
->ctf_syn_ext_strtab
= NULL
;
569 fp
->ctf_link_in_cu_mapping
= NULL
;
570 fp
->ctf_link_out_cu_mapping
= NULL
;
571 fp
->ctf_link_type_mapping
= NULL
;
572 fp
->ctf_parent_unreffed
= 1;
574 fp
->ctf_dvhash
= NULL
;
575 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
576 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
577 fp
->ctf_structs
.ctn_writable
= NULL
;
578 fp
->ctf_unions
.ctn_writable
= NULL
;
579 fp
->ctf_enums
.ctn_writable
= NULL
;
580 fp
->ctf_names
.ctn_writable
= NULL
;
582 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
583 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
584 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
586 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
587 ctf_file_close (nfp
);
593 ctf_name_table (ctf_file_t
*fp
, int kind
)
598 return &fp
->ctf_structs
;
600 return &fp
->ctf_unions
;
602 return &fp
->ctf_enums
;
604 return &fp
->ctf_names
;
609 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
612 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
615 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
616 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
618 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
619 (char *) name
, (void *) dtd
->dtd_type
) < 0)
621 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
625 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
630 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
632 ctf_dmdef_t
*dmd
, *nmd
;
633 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
634 int name_kind
= kind
;
637 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
644 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
645 dmd
!= NULL
; dmd
= nmd
)
647 if (dmd
->dmd_name
!= NULL
)
648 free (dmd
->dmd_name
);
649 nmd
= ctf_list_next (dmd
);
654 free (dtd
->dtd_u
.dtu_argv
);
657 name_kind
= dtd
->dtd_data
.ctt_type
;
661 if (dtd
->dtd_data
.ctt_name
662 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
663 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
665 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
667 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
670 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
675 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
677 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
681 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
685 if (!(fp
->ctf_flags
& LCTF_RDWR
))
688 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
691 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
693 if ((unsigned long) idx
<= fp
->ctf_typemax
)
694 return ctf_dtd_lookup (fp
, id
);
699 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
701 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
703 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
708 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
710 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
711 free (dvd
->dvd_name
);
713 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
718 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
720 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
723 /* Discard all of the dynamic type definitions and variable definitions that
724 have been added to the container since the last call to ctf_update(). We
725 locate such types by scanning the dtd list and deleting elements that have
726 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
727 by scanning the variable list and deleting elements that have update IDs
728 equal to the current value of the last-update snapshot count (indicating that
729 they were added after the most recent call to ctf_update()). */
731 ctf_discard (ctf_file_t
*fp
)
733 ctf_snapshot_id_t last_update
=
735 fp
->ctf_snapshot_lu
+ 1 };
737 /* Update required? */
738 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
741 return (ctf_rollback (fp
, last_update
));
745 ctf_snapshot (ctf_file_t
*fp
)
747 ctf_snapshot_id_t snapid
;
748 snapid
.dtd_id
= fp
->ctf_typemax
;
749 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
753 /* Like ctf_discard(), only discards everything after a particular ID. */
755 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
757 ctf_dtdef_t
*dtd
, *ntd
;
758 ctf_dvdef_t
*dvd
, *nvd
;
760 if (!(fp
->ctf_flags
& LCTF_RDWR
))
761 return (ctf_set_errno (fp
, ECTF_RDONLY
));
763 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
764 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
766 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
771 ntd
= ctf_list_next (dtd
);
773 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
776 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
777 if (kind
== CTF_K_FORWARD
)
778 kind
= dtd
->dtd_data
.ctt_type
;
780 if (dtd
->dtd_data
.ctt_name
781 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
782 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
784 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
786 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
789 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
790 ctf_dtd_delete (fp
, dtd
);
793 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
795 nvd
= ctf_list_next (dvd
);
797 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
800 ctf_dvd_delete (fp
, dvd
);
803 fp
->ctf_typemax
= id
.dtd_id
;
804 fp
->ctf_snapshots
= id
.snapshot_id
;
806 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
807 fp
->ctf_flags
&= ~LCTF_DIRTY
;
813 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
819 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
820 return (ctf_set_errno (fp
, EINVAL
));
822 if (!(fp
->ctf_flags
& LCTF_RDWR
))
823 return (ctf_set_errno (fp
, ECTF_RDONLY
));
825 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
826 return (ctf_set_errno (fp
, ECTF_FULL
));
828 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
829 return (ctf_set_errno (fp
, ECTF_FULL
));
831 /* Make sure ptrtab always grows to be big enough for all types. */
832 if (ctf_grow_ptrtab (fp
) < 0)
833 return CTF_ERR
; /* errno is set for us. */
835 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
836 return (ctf_set_errno (fp
, EAGAIN
));
838 type
= ++fp
->ctf_typemax
;
839 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
841 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
842 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
843 dtd
->dtd_type
= type
;
845 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
848 return (ctf_set_errno (fp
, EAGAIN
));
851 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
854 return CTF_ERR
; /* errno is set for us. */
856 fp
->ctf_flags
|= LCTF_DIRTY
;
862 /* When encoding integer sizes, we want to convert a byte count in the range
863 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
864 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
880 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
881 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
887 return (ctf_set_errno (fp
, EINVAL
));
889 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
890 return CTF_ERR
; /* errno is set for us. */
892 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
893 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
895 dtd
->dtd_u
.dtu_enc
= *ep
;
901 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
905 ctf_file_t
*tmp
= fp
;
906 int child
= fp
->ctf_flags
& LCTF_CHILD
;
908 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
909 return (ctf_set_errno (fp
, EINVAL
));
911 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
912 return CTF_ERR
; /* errno is set for us. */
914 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
915 return CTF_ERR
; /* errno is set for us. */
917 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
918 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
920 if (kind
!= CTF_K_POINTER
)
923 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
924 type and (if an anonymous typedef node is being pointed at) the type that
925 points at too. Note that ctf_typemax is at this point one higher than we
926 want to check against, because it's just been incremented for the addition
929 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
930 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
932 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
933 && ref_idx
< fp
->ctf_typemax
)
935 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
937 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
940 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
941 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
942 && refref_idx
< fp
->ctf_typemax
)
943 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
950 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
951 const ctf_encoding_t
*ep
)
954 ctf_id_t resolved_ref
= ref
;
957 const ctf_type_t
*tp
;
958 ctf_file_t
*tmp
= fp
;
961 return (ctf_set_errno (fp
, EINVAL
));
963 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
964 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
966 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
967 return (ctf_set_errno (fp
, EINVAL
));
969 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
970 return CTF_ERR
; /* errno is set for us. */
972 /* Make sure we ultimately point to an integral type. We also allow slices to
973 point to the unimplemented type, for now, because the compiler can emit
974 such slices, though they're not very much use. */
976 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
977 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
979 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
982 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
984 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
985 return CTF_ERR
; /* errno is set for us. */
987 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
988 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
990 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
991 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
992 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
998 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
999 const char *name
, const ctf_encoding_t
*ep
)
1001 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1005 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1006 const char *name
, const ctf_encoding_t
*ep
)
1008 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1012 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1014 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1018 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1022 ctf_file_t
*tmp
= fp
;
1025 return (ctf_set_errno (fp
, EINVAL
));
1027 if (arp
->ctr_contents
!= 0
1028 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1029 return CTF_ERR
; /* errno is set for us. */
1032 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1033 return CTF_ERR
; /* errno is set for us. */
1035 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1036 return CTF_ERR
; /* errno is set for us. */
1038 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1039 dtd
->dtd_data
.ctt_size
= 0;
1040 dtd
->dtd_u
.dtu_arr
= *arp
;
1046 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1048 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1050 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1051 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1054 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1055 return (ctf_set_errno (fp
, ECTF_BADID
));
1057 fp
->ctf_flags
|= LCTF_DIRTY
;
1058 dtd
->dtd_u
.dtu_arr
= *arp
;
1064 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1065 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1070 uint32_t *vdat
= NULL
;
1071 ctf_file_t
*tmp
= fp
;
1074 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1075 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1076 return (ctf_set_errno (fp
, EINVAL
));
1078 vlen
= ctc
->ctc_argc
;
1079 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1080 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1082 if (ctc
->ctc_return
!= 0
1083 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1084 return CTF_ERR
; /* errno is set for us. */
1086 if (vlen
> CTF_MAX_VLEN
)
1087 return (ctf_set_errno (fp
, EOVERFLOW
));
1089 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1090 return (ctf_set_errno (fp
, EAGAIN
));
1092 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1095 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1098 return CTF_ERR
; /* errno is set for us. */
1100 vdat
[i
] = (uint32_t) argv
[i
];
1103 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1107 return CTF_ERR
; /* errno is set for us. */
1110 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1111 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1113 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1114 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1115 dtd
->dtd_u
.dtu_argv
= vdat
;
1121 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1127 /* Promote root-visible forwards to structs. */
1129 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1131 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1132 dtd
= ctf_dtd_lookup (fp
, type
);
1133 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1135 return CTF_ERR
; /* errno is set for us. */
1137 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1139 if (size
> CTF_MAX_SIZE
)
1141 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1142 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1143 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1146 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1152 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1154 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1158 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1164 /* Promote root-visible forwards to unions. */
1166 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1168 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1169 dtd
= ctf_dtd_lookup (fp
, type
);
1170 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1172 return CTF_ERR
; /* errno is set for us */
1174 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1176 if (size
> CTF_MAX_SIZE
)
1178 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1179 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1180 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1183 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1189 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1191 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1195 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1200 /* Promote root-visible forwards to enums. */
1202 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1204 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1205 dtd
= ctf_dtd_lookup (fp
, type
);
1206 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1208 return CTF_ERR
; /* errno is set for us. */
1210 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1211 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1217 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1218 const ctf_encoding_t
*ep
)
1222 /* First, create the enum if need be, using most of the same machinery as
1223 ctf_add_enum(), to ensure that we do not allow things past that are not
1224 enums or forwards to them. (This includes other slices: you cannot slice a
1225 slice, which would be a useless thing to do anyway.) */
1228 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1232 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1233 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1234 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1236 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1237 return CTF_ERR
; /* errno is set for us. */
1239 /* Now attach a suitable slice to it. */
1241 return ctf_add_slice (fp
, flag
, type
, ep
);
1245 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1251 if (!ctf_forwardable_kind (kind
))
1252 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1254 /* If the type is already defined or exists as a forward tag, just
1255 return the ctf_id_t of the existing definition. */
1258 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1263 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1264 return CTF_ERR
; /* errno is set for us. */
1266 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1267 dtd
->dtd_data
.ctt_type
= kind
;
1273 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1278 ctf_file_t
*tmp
= fp
;
1280 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1281 return (ctf_set_errno (fp
, EINVAL
));
1283 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1284 return CTF_ERR
; /* errno is set for us. */
1286 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1288 return CTF_ERR
; /* errno is set for us. */
1290 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1291 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1297 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1299 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1303 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1305 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1309 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1311 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1315 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1318 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1321 uint32_t kind
, vlen
, root
;
1325 return (ctf_set_errno (fp
, EINVAL
));
1327 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1328 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1331 return (ctf_set_errno (fp
, ECTF_BADID
));
1333 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1334 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1335 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1337 if (kind
!= CTF_K_ENUM
)
1338 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1340 if (vlen
== CTF_MAX_VLEN
)
1341 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1343 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1344 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1346 if (strcmp (dmd
->dmd_name
, name
) == 0)
1347 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1350 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1351 return (ctf_set_errno (fp
, EAGAIN
));
1353 if ((s
= strdup (name
)) == NULL
)
1356 return (ctf_set_errno (fp
, EAGAIN
));
1360 dmd
->dmd_type
= CTF_ERR
;
1361 dmd
->dmd_offset
= 0;
1362 dmd
->dmd_value
= value
;
1364 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1365 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1367 fp
->ctf_flags
|= LCTF_DIRTY
;
1373 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1374 ctf_id_t type
, unsigned long bit_offset
)
1376 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1379 ssize_t msize
, malign
, ssize
;
1380 uint32_t kind
, vlen
, root
;
1383 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1384 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1387 return (ctf_set_errno (fp
, ECTF_BADID
));
1389 if (name
!= NULL
&& name
[0] == '\0')
1392 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1393 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1394 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1396 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1397 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1399 if (vlen
== CTF_MAX_VLEN
)
1400 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1404 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1405 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1407 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1408 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1412 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1413 (malign
= ctf_type_align (fp
, type
)) < 0)
1415 /* The unimplemented type, and any type that resolves to it, has no size
1416 and no alignment: it can correspond to any number of compiler-inserted
1419 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1423 ctf_set_errno (fp
, 0);
1426 return -1; /* errno is set for us. */
1429 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1430 return (ctf_set_errno (fp
, EAGAIN
));
1432 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1435 return (ctf_set_errno (fp
, EAGAIN
));
1439 dmd
->dmd_type
= type
;
1440 dmd
->dmd_value
= -1;
1442 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1444 if (bit_offset
== (unsigned long) - 1)
1446 /* Natural alignment. */
1448 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1449 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1450 size_t off
= lmd
->dmd_offset
;
1452 ctf_encoding_t linfo
;
1455 /* Propagate any error from ctf_type_resolve. If the last member was
1456 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1457 cannot insert right after such a member without explicit offset
1458 specification, because its alignment and size is not known. */
1459 if (ltype
== CTF_ERR
)
1462 return -1; /* errno is set for us. */
1465 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1466 off
+= linfo
.cte_bits
;
1467 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1468 off
+= lsize
* CHAR_BIT
;
1470 /* Round up the offset of the end of the last member to
1471 the next byte boundary, convert 'off' to bytes, and
1472 then round it up again to the next multiple of the
1473 alignment required by the new member. Finally,
1474 convert back to bits and store the result in
1475 dmd_offset. Technically we could do more efficient
1476 packing if the new member is a bit-field, but we're
1477 the "compiler" and ANSI says we can do as we choose. */
1479 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1480 off
= roundup (off
, MAX (malign
, 1));
1481 dmd
->dmd_offset
= off
* CHAR_BIT
;
1482 ssize
= off
+ msize
;
1486 /* Specified offset in bits. */
1488 dmd
->dmd_offset
= bit_offset
;
1489 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1490 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1495 dmd
->dmd_offset
= 0;
1496 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1497 ssize
= MAX (ssize
, msize
);
1500 if ((size_t) ssize
> CTF_MAX_SIZE
)
1502 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1503 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1504 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1507 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1509 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1510 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1512 fp
->ctf_flags
|= LCTF_DIRTY
;
1517 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1518 ctf_id_t type
, unsigned long bit_offset
,
1519 const ctf_encoding_t encoding
)
1521 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1522 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1525 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1526 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1528 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1529 return -1; /* errno is set for us. */
1531 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1535 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1538 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1542 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1545 ctf_file_t
*tmp
= fp
;
1547 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1548 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1550 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1551 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1553 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1554 return -1; /* errno is set for us. */
1556 /* Make sure this type is representable. */
1557 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1558 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1561 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1562 return (ctf_set_errno (fp
, EAGAIN
));
1564 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1567 return (ctf_set_errno (fp
, EAGAIN
));
1569 dvd
->dvd_type
= ref
;
1570 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1572 if (ctf_dvd_insert (fp
, dvd
) < 0)
1574 free (dvd
->dvd_name
);
1576 return -1; /* errno is set for us. */
1579 fp
->ctf_flags
|= LCTF_DIRTY
;
1584 enumcmp (const char *name
, int value
, void *arg
)
1586 ctf_bundle_t
*ctb
= arg
;
1589 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1591 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1592 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1595 if (value
!= bvalue
)
1597 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1605 enumadd (const char *name
, int value
, void *arg
)
1607 ctf_bundle_t
*ctb
= arg
;
1609 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1614 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1617 ctf_bundle_t
*ctb
= arg
;
1620 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1625 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1627 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1628 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1631 if (ctm
.ctm_offset
!= offset
)
1633 ctf_dprintf ("Conflict due to member %s offset change: "
1634 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1641 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1643 ctf_bundle_t
*ctb
= arg
;
1647 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1648 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1650 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1653 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1656 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1657 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1659 dmd
->dmd_type
= type
;
1660 dmd
->dmd_offset
= offset
;
1661 dmd
->dmd_value
= -1;
1663 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1665 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1669 /* The ctf_add_type routine is used to copy a type from a source CTF container
1670 to a dynamic destination container. This routine operates recursively by
1671 following the source type's links and embedded member types. If the
1672 destination container already contains a named type which has the same
1673 attributes, then we succeed and return this type but no changes occur. */
1675 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1676 ctf_file_t
*proc_tracking_fp
)
1678 ctf_id_t dst_type
= CTF_ERR
;
1679 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1680 ctf_file_t
*tmp_fp
= dst_fp
;
1684 uint32_t kind
, forward_kind
, flag
, vlen
;
1686 const ctf_type_t
*src_tp
, *dst_tp
;
1687 ctf_bundle_t src
, dst
;
1688 ctf_encoding_t src_en
, dst_en
;
1689 ctf_arinfo_t src_ar
, dst_ar
;
1693 ctf_id_t orig_src_type
= src_type
;
1695 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1696 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1698 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1699 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1701 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1702 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1703 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1705 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1706 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1707 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1708 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1710 /* If this is a type we are currently in the middle of adding, hand it
1711 straight back. (This lets us handle self-referential structures without
1712 considering forwards and empty structures the same as their completed
1715 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1719 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1720 (void *) (uintptr_t) src_type
))
1723 /* If this type has already been added from this container, and is the same
1724 kind and (if a struct or union) has the same number of members, hand it
1727 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1729 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1730 || kind
== CTF_K_ENUM
)
1732 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1733 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1741 forward_kind
= kind
;
1742 if (kind
== CTF_K_FORWARD
)
1743 forward_kind
= src_tp
->ctt_type
;
1745 /* If the source type has a name and is a root type (visible at the
1746 top-level scope), lookup the name in the destination container and
1747 verify that it is of the same kind before we do anything else. */
1749 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1750 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1753 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1756 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1757 unless dst_type is a forward declaration and src_type is a struct,
1758 union, or enum (i.e. the definition of the previous forward decl).
1760 We also allow addition in the opposite order (addition of a forward when a
1761 struct, union, or enum already exists), which is a NOP and returns the
1762 already-present struct, union, or enum. */
1764 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1766 if (kind
== CTF_K_FORWARD
1767 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1768 || dst_kind
== CTF_K_UNION
))
1770 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1774 if (dst_kind
!= CTF_K_FORWARD
1775 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1776 && kind
!= CTF_K_UNION
))
1778 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1779 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1780 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1784 /* We take special action for an integer, float, or slice since it is
1785 described not only by its name but also its encoding. For integers,
1786 bit-fields exploit this degeneracy. */
1788 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1790 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1791 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1793 if (dst_type
!= CTF_ERR
)
1795 ctf_file_t
*fp
= dst_fp
;
1797 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1800 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1801 return CTF_ERR
; /* errno set for us. */
1803 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1805 /* The type that we found in the hash is also root-visible. If
1806 the two types match then use the existing one; otherwise,
1807 declare a conflict. Note: slices are not certain to match
1808 even if there is no conflict: we must check the contained type
1811 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1813 if (kind
!= CTF_K_SLICE
)
1815 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1821 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1826 /* We found a non-root-visible type in the hash. If its encoding
1827 is the same, we can reuse it, unless it is a slice. */
1829 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1831 if (kind
!= CTF_K_SLICE
)
1833 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1841 src
.ctb_file
= src_fp
;
1842 src
.ctb_type
= src_type
;
1845 dst
.ctb_file
= dst_fp
;
1846 dst
.ctb_type
= dst_type
;
1849 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1850 a new type with the same properties as src_type to dst_fp. If dst_type is
1851 not CTF_ERR, then we verify that dst_type has the same attributes as
1852 src_type. We recurse for embedded references. Before we start, we note
1853 that we are processing this type, to prevent infinite recursion: we do not
1854 re-process any type that appears in this list. The list is emptied
1855 wholesale at the end of processing everything in this recursive stack. */
1857 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1858 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1859 return ctf_set_errno (dst_fp
, ENOMEM
);
1864 /* If we found a match we will have either returned it or declared a
1866 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1870 /* If we found a match we will have either returned it or declared a
1872 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1876 /* We have checked for conflicting encodings: now try to add the
1878 src_type
= ctf_type_reference (src_fp
, src_type
);
1879 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1882 if (src_type
== CTF_ERR
)
1883 return CTF_ERR
; /* errno is set for us. */
1885 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1889 case CTF_K_VOLATILE
:
1891 case CTF_K_RESTRICT
:
1892 src_type
= ctf_type_reference (src_fp
, src_type
);
1893 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1896 if (src_type
== CTF_ERR
)
1897 return CTF_ERR
; /* errno is set for us. */
1899 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1903 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1904 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1906 src_ar
.ctr_contents
=
1907 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1909 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1912 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1914 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1915 return CTF_ERR
; /* errno is set for us. */
1917 if (dst_type
!= CTF_ERR
)
1919 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1920 return CTF_ERR
; /* errno is set for us. */
1922 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1924 ctf_dprintf ("Conflict for type %s against ID %lx: "
1925 "array info differs, old %lx/%lx/%x; "
1926 "new: %lx/%lx/%x\n", name
, dst_type
,
1927 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1928 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1929 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1930 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1934 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1937 case CTF_K_FUNCTION
:
1938 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1944 if (ctc
.ctc_return
== CTF_ERR
)
1945 return CTF_ERR
; /* errno is set for us. */
1947 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1959 /* Technically to match a struct or union we need to check both
1960 ways (src members vs. dst, dst members vs. src) but we make
1961 this more optimal by only checking src vs. dst and comparing
1962 the total size of the structure (which we must do anyway)
1963 which covers the possibility of dst members not in src.
1964 This optimization can be defeated for unions, but is so
1965 pathological as to render it irrelevant for our purposes. */
1967 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1968 && dst_kind
!= CTF_K_FORWARD
)
1970 if (ctf_type_size (src_fp
, src_type
) !=
1971 ctf_type_size (dst_fp
, dst_type
))
1973 ctf_dprintf ("Conflict for type %s against ID %lx: "
1974 "union size differs, old %li, new %li\n",
1976 (long) ctf_type_size (src_fp
, src_type
),
1977 (long) ctf_type_size (dst_fp
, dst_type
));
1978 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1981 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1983 ctf_dprintf ("Conflict for type %s against ID %lx: "
1984 "members differ, see above\n", name
, dst_type
);
1985 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1991 /* Unlike the other cases, copying structs and unions is done
1992 manually so as to avoid repeated lookups in ctf_add_member
1993 and to ensure the exact same member offsets as in src_type. */
1995 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1996 if (dst_type
== CTF_ERR
)
1997 return CTF_ERR
; /* errno is set for us. */
1999 dst
.ctb_type
= dst_type
;
2002 /* Pre-emptively add this struct to the type mapping so that
2003 structures that refer to themselves work. */
2004 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2006 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2007 errs
++; /* Increment errs and fail at bottom of case. */
2009 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2010 return CTF_ERR
; /* errno is set for us. */
2012 size
= (size_t) ssize
;
2013 if (size
> CTF_MAX_SIZE
)
2015 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2016 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2017 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2020 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2022 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2024 /* Make a final pass through the members changing each dmd_type (a
2025 src_fp type) to an equivalent type in dst_fp. We pass through all
2026 members, leaving any that fail set to CTF_ERR, unless they fail
2027 because they are marking a member of type not representable in this
2028 version of CTF, in which case we just want to silently omit them:
2029 no consumer can do anything with them anyway. */
2030 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2031 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2033 ctf_file_t
*dst
= dst_fp
;
2036 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2039 if ((dmd
->dmd_type
=
2040 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2041 proc_tracking_fp
)) == CTF_ERR
)
2043 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2048 dmd
->dmd_type
= memb_type
;
2052 return CTF_ERR
; /* errno is set for us. */
2057 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2058 && dst_kind
!= CTF_K_FORWARD
)
2060 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2061 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2063 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2064 "members differ, see above\n", name
, dst_type
);
2065 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2070 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2071 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2072 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2073 return CTF_ERR
; /* errno is set for us */
2078 if (dst_type
== CTF_ERR
)
2079 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2083 src_type
= ctf_type_reference (src_fp
, src_type
);
2084 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2087 if (src_type
== CTF_ERR
)
2088 return CTF_ERR
; /* errno is set for us. */
2090 /* If dst_type is not CTF_ERR at this point, we should check if
2091 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2092 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2093 that vary based on things like if 32-bit then pid_t is int otherwise
2094 long. We therefore omit this check and assume that if the identically
2095 named typedef already exists in dst_fp, it is correct or
2098 if (dst_type
== CTF_ERR
)
2099 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2104 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2107 if (dst_type
!= CTF_ERR
)
2108 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2113 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2117 if (!src_fp
->ctf_add_processing
)
2118 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2119 ctf_hash_eq_integer
,
2122 /* We store the hash on the source, because it contains only source type IDs:
2123 but callers will invariably expect errors to appear on the dest. */
2124 if (!src_fp
->ctf_add_processing
)
2125 return (ctf_set_errno (dst_fp
, ENOMEM
));
2127 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2128 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2133 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2135 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2137 const unsigned char *buf
;
2141 resid
= sizeof (ctf_header_t
);
2142 buf
= (unsigned char *) fp
->ctf_header
;
2145 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2146 return (ctf_set_errno (fp
, errno
));
2151 resid
= fp
->ctf_size
;
2155 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2156 return (ctf_set_errno (fp
, errno
));
2164 /* Compress the specified CTF data stream and write it to the specified file
2167 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2172 ctf_header_t
*hp
= &h
;
2173 ssize_t header_len
= sizeof (ctf_header_t
);
2174 ssize_t compress_len
;
2179 if (ctf_serialize (fp
) < 0)
2180 return -1; /* errno is set for us. */
2182 memcpy (hp
, fp
->ctf_header
, header_len
);
2183 hp
->cth_flags
|= CTF_F_COMPRESS
;
2184 compress_len
= compressBound (fp
->ctf_size
);
2186 if ((buf
= malloc (compress_len
)) == NULL
)
2187 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2189 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2190 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2192 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2193 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2197 while (header_len
> 0)
2199 if ((len
= write (fd
, hp
, header_len
)) < 0)
2201 err
= ctf_set_errno (fp
, errno
);
2209 while (compress_len
> 0)
2211 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2213 err
= ctf_set_errno (fp
, errno
);
2216 compress_len
-= len
;
2225 /* Optionally compress the specified CTF data stream and return it as a new
2226 dynamically-allocated string. */
2228 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2233 ssize_t header_len
= sizeof (ctf_header_t
);
2234 ssize_t compress_len
;
2237 if (ctf_serialize (fp
) < 0)
2238 return NULL
; /* errno is set for us. */
2240 compress_len
= compressBound (fp
->ctf_size
);
2241 if (fp
->ctf_size
< threshold
)
2242 compress_len
= fp
->ctf_size
;
2243 if ((buf
= malloc (compress_len
2244 + sizeof (struct ctf_header
))) == NULL
)
2246 ctf_set_errno (fp
, ENOMEM
);
2250 hp
= (ctf_header_t
*) buf
;
2251 memcpy (hp
, fp
->ctf_header
, header_len
);
2252 bp
= buf
+ sizeof (struct ctf_header
);
2253 *size
= sizeof (struct ctf_header
);
2255 if (fp
->ctf_size
< threshold
)
2257 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2258 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2259 *size
+= fp
->ctf_size
;
2263 hp
->cth_flags
|= CTF_F_COMPRESS
;
2264 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2265 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2267 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2268 ctf_set_errno (fp
, ECTF_COMPRESS
);
2272 *size
+= compress_len
;
2277 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2279 ctf_write (ctf_file_t
*fp
, int fd
)
2281 const unsigned char *buf
;
2285 if (ctf_serialize (fp
) < 0)
2286 return -1; /* errno is set for us. */
2288 resid
= sizeof (ctf_header_t
);
2289 buf
= (unsigned char *) fp
->ctf_header
;
2292 if ((len
= write (fd
, buf
, resid
)) <= 0)
2293 return (ctf_set_errno (fp
, errno
));
2298 resid
= fp
->ctf_size
;
2302 if ((len
= write (fd
, buf
, resid
)) <= 0)
2303 return (ctf_set_errno (fp
, errno
));