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_variable_filter
= fp
->ctf_link_variable_filter
;
547 nfp
->ctf_link_variable_filter_arg
= fp
->ctf_link_variable_filter_arg
;
548 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
550 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
552 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
553 nfp
->ctf_structs
= fp
->ctf_structs
;
554 nfp
->ctf_unions
= fp
->ctf_unions
;
555 nfp
->ctf_enums
= fp
->ctf_enums
;
556 nfp
->ctf_names
= fp
->ctf_names
;
558 fp
->ctf_dthash
= NULL
;
559 ctf_str_free_atoms (nfp
);
560 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
561 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
562 fp
->ctf_str_atoms
= NULL
;
563 fp
->ctf_prov_strtab
= NULL
;
564 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
565 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
566 fp
->ctf_add_processing
= NULL
;
567 fp
->ctf_ptrtab
= NULL
;
568 fp
->ctf_link_inputs
= NULL
;
569 fp
->ctf_link_outputs
= NULL
;
570 fp
->ctf_syn_ext_strtab
= NULL
;
571 fp
->ctf_link_in_cu_mapping
= NULL
;
572 fp
->ctf_link_out_cu_mapping
= NULL
;
573 fp
->ctf_link_type_mapping
= NULL
;
574 fp
->ctf_parent_unreffed
= 1;
576 fp
->ctf_dvhash
= NULL
;
577 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
578 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
579 fp
->ctf_structs
.ctn_writable
= NULL
;
580 fp
->ctf_unions
.ctn_writable
= NULL
;
581 fp
->ctf_enums
.ctn_writable
= NULL
;
582 fp
->ctf_names
.ctn_writable
= NULL
;
584 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
585 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
586 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
588 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
589 ctf_file_close (nfp
);
595 ctf_name_table (ctf_file_t
*fp
, int kind
)
600 return &fp
->ctf_structs
;
602 return &fp
->ctf_unions
;
604 return &fp
->ctf_enums
;
606 return &fp
->ctf_names
;
611 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
614 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
617 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
618 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
620 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
621 (char *) name
, (void *) dtd
->dtd_type
) < 0)
623 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
627 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
632 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
634 ctf_dmdef_t
*dmd
, *nmd
;
635 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
636 int name_kind
= kind
;
639 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
646 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
647 dmd
!= NULL
; dmd
= nmd
)
649 if (dmd
->dmd_name
!= NULL
)
650 free (dmd
->dmd_name
);
651 nmd
= ctf_list_next (dmd
);
656 free (dtd
->dtd_u
.dtu_argv
);
659 name_kind
= dtd
->dtd_data
.ctt_type
;
663 if (dtd
->dtd_data
.ctt_name
664 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
665 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
667 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
669 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
672 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
677 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
679 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
683 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
687 if (!(fp
->ctf_flags
& LCTF_RDWR
))
690 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
693 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
695 if ((unsigned long) idx
<= fp
->ctf_typemax
)
696 return ctf_dtd_lookup (fp
, id
);
701 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
703 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
705 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
710 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
712 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
713 free (dvd
->dvd_name
);
715 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
720 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
722 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
725 /* Discard all of the dynamic type definitions and variable definitions that
726 have been added to the container since the last call to ctf_update(). We
727 locate such types by scanning the dtd list and deleting elements that have
728 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
729 by scanning the variable list and deleting elements that have update IDs
730 equal to the current value of the last-update snapshot count (indicating that
731 they were added after the most recent call to ctf_update()). */
733 ctf_discard (ctf_file_t
*fp
)
735 ctf_snapshot_id_t last_update
=
737 fp
->ctf_snapshot_lu
+ 1 };
739 /* Update required? */
740 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
743 return (ctf_rollback (fp
, last_update
));
747 ctf_snapshot (ctf_file_t
*fp
)
749 ctf_snapshot_id_t snapid
;
750 snapid
.dtd_id
= fp
->ctf_typemax
;
751 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
755 /* Like ctf_discard(), only discards everything after a particular ID. */
757 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
759 ctf_dtdef_t
*dtd
, *ntd
;
760 ctf_dvdef_t
*dvd
, *nvd
;
762 if (!(fp
->ctf_flags
& LCTF_RDWR
))
763 return (ctf_set_errno (fp
, ECTF_RDONLY
));
765 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
766 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
768 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
773 ntd
= ctf_list_next (dtd
);
775 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
778 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
779 if (kind
== CTF_K_FORWARD
)
780 kind
= dtd
->dtd_data
.ctt_type
;
782 if (dtd
->dtd_data
.ctt_name
783 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
784 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
786 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
788 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
791 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
792 ctf_dtd_delete (fp
, dtd
);
795 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
797 nvd
= ctf_list_next (dvd
);
799 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
802 ctf_dvd_delete (fp
, dvd
);
805 fp
->ctf_typemax
= id
.dtd_id
;
806 fp
->ctf_snapshots
= id
.snapshot_id
;
808 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
809 fp
->ctf_flags
&= ~LCTF_DIRTY
;
815 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
821 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
822 return (ctf_set_errno (fp
, EINVAL
));
824 if (!(fp
->ctf_flags
& LCTF_RDWR
))
825 return (ctf_set_errno (fp
, ECTF_RDONLY
));
827 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
828 return (ctf_set_errno (fp
, ECTF_FULL
));
830 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
831 return (ctf_set_errno (fp
, ECTF_FULL
));
833 /* Make sure ptrtab always grows to be big enough for all types. */
834 if (ctf_grow_ptrtab (fp
) < 0)
835 return CTF_ERR
; /* errno is set for us. */
837 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
838 return (ctf_set_errno (fp
, EAGAIN
));
840 type
= ++fp
->ctf_typemax
;
841 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
843 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
844 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
845 dtd
->dtd_type
= type
;
847 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
850 return (ctf_set_errno (fp
, EAGAIN
));
853 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
856 return CTF_ERR
; /* errno is set for us. */
858 fp
->ctf_flags
|= LCTF_DIRTY
;
864 /* When encoding integer sizes, we want to convert a byte count in the range
865 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
866 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
882 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
883 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
889 return (ctf_set_errno (fp
, EINVAL
));
891 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
892 return CTF_ERR
; /* errno is set for us. */
894 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
895 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
897 dtd
->dtd_u
.dtu_enc
= *ep
;
903 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
907 ctf_file_t
*tmp
= fp
;
908 int child
= fp
->ctf_flags
& LCTF_CHILD
;
910 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
911 return (ctf_set_errno (fp
, EINVAL
));
913 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
914 return CTF_ERR
; /* errno is set for us. */
916 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
917 return CTF_ERR
; /* errno is set for us. */
919 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
920 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
922 if (kind
!= CTF_K_POINTER
)
925 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
926 type and (if an anonymous typedef node is being pointed at) the type that
927 points at too. Note that ctf_typemax is at this point one higher than we
928 want to check against, because it's just been incremented for the addition
931 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
932 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
934 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
935 && ref_idx
< fp
->ctf_typemax
)
937 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
939 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
942 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
943 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
944 && refref_idx
< fp
->ctf_typemax
)
945 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
952 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
953 const ctf_encoding_t
*ep
)
956 ctf_id_t resolved_ref
= ref
;
959 const ctf_type_t
*tp
;
960 ctf_file_t
*tmp
= fp
;
963 return (ctf_set_errno (fp
, EINVAL
));
965 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
966 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
968 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
969 return (ctf_set_errno (fp
, EINVAL
));
971 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
972 return CTF_ERR
; /* errno is set for us. */
974 /* Make sure we ultimately point to an integral type. We also allow slices to
975 point to the unimplemented type, for now, because the compiler can emit
976 such slices, though they're not very much use. */
978 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
979 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
981 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
984 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
986 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
987 return CTF_ERR
; /* errno is set for us. */
989 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
990 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
992 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
993 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
994 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
1000 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
1001 const char *name
, const ctf_encoding_t
*ep
)
1003 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1007 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1008 const char *name
, const ctf_encoding_t
*ep
)
1010 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1014 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1016 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1020 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1024 ctf_file_t
*tmp
= fp
;
1027 return (ctf_set_errno (fp
, EINVAL
));
1029 if (arp
->ctr_contents
!= 0
1030 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1031 return CTF_ERR
; /* errno is set for us. */
1034 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1035 return CTF_ERR
; /* errno is set for us. */
1037 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1038 return CTF_ERR
; /* errno is set for us. */
1040 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1041 dtd
->dtd_data
.ctt_size
= 0;
1042 dtd
->dtd_u
.dtu_arr
= *arp
;
1048 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1050 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1052 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1053 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1056 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1057 return (ctf_set_errno (fp
, ECTF_BADID
));
1059 fp
->ctf_flags
|= LCTF_DIRTY
;
1060 dtd
->dtd_u
.dtu_arr
= *arp
;
1066 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1067 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1072 uint32_t *vdat
= NULL
;
1073 ctf_file_t
*tmp
= fp
;
1076 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1077 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1078 return (ctf_set_errno (fp
, EINVAL
));
1080 vlen
= ctc
->ctc_argc
;
1081 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1082 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1084 if (ctc
->ctc_return
!= 0
1085 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1086 return CTF_ERR
; /* errno is set for us. */
1088 if (vlen
> CTF_MAX_VLEN
)
1089 return (ctf_set_errno (fp
, EOVERFLOW
));
1091 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1092 return (ctf_set_errno (fp
, EAGAIN
));
1094 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1097 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1100 return CTF_ERR
; /* errno is set for us. */
1102 vdat
[i
] = (uint32_t) argv
[i
];
1105 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1109 return CTF_ERR
; /* errno is set for us. */
1112 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1113 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1115 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1116 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1117 dtd
->dtd_u
.dtu_argv
= vdat
;
1123 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1129 /* Promote root-visible forwards to structs. */
1131 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1133 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1134 dtd
= ctf_dtd_lookup (fp
, type
);
1135 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1137 return CTF_ERR
; /* errno is set for us. */
1139 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1141 if (size
> CTF_MAX_SIZE
)
1143 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1144 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1145 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1148 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1154 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1156 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1160 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1166 /* Promote root-visible forwards to unions. */
1168 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1170 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1171 dtd
= ctf_dtd_lookup (fp
, type
);
1172 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1174 return CTF_ERR
; /* errno is set for us */
1176 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1178 if (size
> CTF_MAX_SIZE
)
1180 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1181 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1182 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1185 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1191 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1193 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1197 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1202 /* Promote root-visible forwards to enums. */
1204 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1206 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1207 dtd
= ctf_dtd_lookup (fp
, type
);
1208 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1210 return CTF_ERR
; /* errno is set for us. */
1212 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1213 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1219 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1220 const ctf_encoding_t
*ep
)
1224 /* First, create the enum if need be, using most of the same machinery as
1225 ctf_add_enum(), to ensure that we do not allow things past that are not
1226 enums or forwards to them. (This includes other slices: you cannot slice a
1227 slice, which would be a useless thing to do anyway.) */
1230 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1234 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1235 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1236 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1238 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1239 return CTF_ERR
; /* errno is set for us. */
1241 /* Now attach a suitable slice to it. */
1243 return ctf_add_slice (fp
, flag
, type
, ep
);
1247 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1253 if (!ctf_forwardable_kind (kind
))
1254 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1256 /* If the type is already defined or exists as a forward tag, just
1257 return the ctf_id_t of the existing definition. */
1260 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1265 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1266 return CTF_ERR
; /* errno is set for us. */
1268 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1269 dtd
->dtd_data
.ctt_type
= kind
;
1275 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1280 ctf_file_t
*tmp
= fp
;
1282 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1283 return (ctf_set_errno (fp
, EINVAL
));
1285 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1286 return CTF_ERR
; /* errno is set for us. */
1288 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1290 return CTF_ERR
; /* errno is set for us. */
1292 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1293 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1299 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1301 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1305 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1307 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1311 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1313 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1317 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1320 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1323 uint32_t kind
, vlen
, root
;
1327 return (ctf_set_errno (fp
, EINVAL
));
1329 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1330 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1333 return (ctf_set_errno (fp
, ECTF_BADID
));
1335 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1336 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1337 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1339 if (kind
!= CTF_K_ENUM
)
1340 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1342 if (vlen
== CTF_MAX_VLEN
)
1343 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1345 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1346 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1348 if (strcmp (dmd
->dmd_name
, name
) == 0)
1349 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1352 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1353 return (ctf_set_errno (fp
, EAGAIN
));
1355 if ((s
= strdup (name
)) == NULL
)
1358 return (ctf_set_errno (fp
, EAGAIN
));
1362 dmd
->dmd_type
= CTF_ERR
;
1363 dmd
->dmd_offset
= 0;
1364 dmd
->dmd_value
= value
;
1366 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1367 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1369 fp
->ctf_flags
|= LCTF_DIRTY
;
1375 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1376 ctf_id_t type
, unsigned long bit_offset
)
1378 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1381 ssize_t msize
, malign
, ssize
;
1382 uint32_t kind
, vlen
, root
;
1385 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1386 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1389 return (ctf_set_errno (fp
, ECTF_BADID
));
1391 if (name
!= NULL
&& name
[0] == '\0')
1394 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1395 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1396 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1398 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1399 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1401 if (vlen
== CTF_MAX_VLEN
)
1402 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1406 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1407 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1409 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1410 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1414 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1415 (malign
= ctf_type_align (fp
, type
)) < 0)
1417 /* The unimplemented type, and any type that resolves to it, has no size
1418 and no alignment: it can correspond to any number of compiler-inserted
1421 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1425 ctf_set_errno (fp
, 0);
1428 return -1; /* errno is set for us. */
1431 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1432 return (ctf_set_errno (fp
, EAGAIN
));
1434 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1437 return (ctf_set_errno (fp
, EAGAIN
));
1441 dmd
->dmd_type
= type
;
1442 dmd
->dmd_value
= -1;
1444 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1446 if (bit_offset
== (unsigned long) - 1)
1448 /* Natural alignment. */
1450 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1451 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1452 size_t off
= lmd
->dmd_offset
;
1454 ctf_encoding_t linfo
;
1457 /* Propagate any error from ctf_type_resolve. If the last member was
1458 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1459 cannot insert right after such a member without explicit offset
1460 specification, because its alignment and size is not known. */
1461 if (ltype
== CTF_ERR
)
1464 return -1; /* errno is set for us. */
1467 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1468 off
+= linfo
.cte_bits
;
1469 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1470 off
+= lsize
* CHAR_BIT
;
1472 /* Round up the offset of the end of the last member to
1473 the next byte boundary, convert 'off' to bytes, and
1474 then round it up again to the next multiple of the
1475 alignment required by the new member. Finally,
1476 convert back to bits and store the result in
1477 dmd_offset. Technically we could do more efficient
1478 packing if the new member is a bit-field, but we're
1479 the "compiler" and ANSI says we can do as we choose. */
1481 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1482 off
= roundup (off
, MAX (malign
, 1));
1483 dmd
->dmd_offset
= off
* CHAR_BIT
;
1484 ssize
= off
+ msize
;
1488 /* Specified offset in bits. */
1490 dmd
->dmd_offset
= bit_offset
;
1491 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1492 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1497 dmd
->dmd_offset
= 0;
1498 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1499 ssize
= MAX (ssize
, msize
);
1502 if ((size_t) ssize
> CTF_MAX_SIZE
)
1504 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1505 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1506 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1509 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1511 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1512 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1514 fp
->ctf_flags
|= LCTF_DIRTY
;
1519 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1520 ctf_id_t type
, unsigned long bit_offset
,
1521 const ctf_encoding_t encoding
)
1523 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1524 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1527 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1528 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1530 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1531 return -1; /* errno is set for us. */
1533 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1537 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1540 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1544 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1547 ctf_file_t
*tmp
= fp
;
1549 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1550 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1552 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1553 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1555 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1556 return -1; /* errno is set for us. */
1558 /* Make sure this type is representable. */
1559 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1560 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1563 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1564 return (ctf_set_errno (fp
, EAGAIN
));
1566 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1569 return (ctf_set_errno (fp
, EAGAIN
));
1571 dvd
->dvd_type
= ref
;
1572 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1574 if (ctf_dvd_insert (fp
, dvd
) < 0)
1576 free (dvd
->dvd_name
);
1578 return -1; /* errno is set for us. */
1581 fp
->ctf_flags
|= LCTF_DIRTY
;
1586 enumcmp (const char *name
, int value
, void *arg
)
1588 ctf_bundle_t
*ctb
= arg
;
1591 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1593 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1594 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1597 if (value
!= bvalue
)
1599 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1607 enumadd (const char *name
, int value
, void *arg
)
1609 ctf_bundle_t
*ctb
= arg
;
1611 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1616 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1619 ctf_bundle_t
*ctb
= arg
;
1622 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1627 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1629 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1630 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1633 if (ctm
.ctm_offset
!= offset
)
1635 ctf_dprintf ("Conflict due to member %s offset change: "
1636 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1643 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1645 ctf_bundle_t
*ctb
= arg
;
1649 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1650 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1652 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1655 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1658 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1659 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1661 dmd
->dmd_type
= type
;
1662 dmd
->dmd_offset
= offset
;
1663 dmd
->dmd_value
= -1;
1665 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1667 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1671 /* The ctf_add_type routine is used to copy a type from a source CTF container
1672 to a dynamic destination container. This routine operates recursively by
1673 following the source type's links and embedded member types. If the
1674 destination container already contains a named type which has the same
1675 attributes, then we succeed and return this type but no changes occur. */
1677 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1678 ctf_file_t
*proc_tracking_fp
)
1680 ctf_id_t dst_type
= CTF_ERR
;
1681 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1682 ctf_file_t
*tmp_fp
= dst_fp
;
1686 uint32_t kind
, forward_kind
, flag
, vlen
;
1688 const ctf_type_t
*src_tp
, *dst_tp
;
1689 ctf_bundle_t src
, dst
;
1690 ctf_encoding_t src_en
, dst_en
;
1691 ctf_arinfo_t src_ar
, dst_ar
;
1695 ctf_id_t orig_src_type
= src_type
;
1697 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1698 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1700 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1701 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1703 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1704 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1705 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1707 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1708 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1709 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1710 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1712 /* If this is a type we are currently in the middle of adding, hand it
1713 straight back. (This lets us handle self-referential structures without
1714 considering forwards and empty structures the same as their completed
1717 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1721 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1722 (void *) (uintptr_t) src_type
))
1725 /* If this type has already been added from this container, and is the same
1726 kind and (if a struct or union) has the same number of members, hand it
1729 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1731 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1732 || kind
== CTF_K_ENUM
)
1734 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1735 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1743 forward_kind
= kind
;
1744 if (kind
== CTF_K_FORWARD
)
1745 forward_kind
= src_tp
->ctt_type
;
1747 /* If the source type has a name and is a root type (visible at the
1748 top-level scope), lookup the name in the destination container and
1749 verify that it is of the same kind before we do anything else. */
1751 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1752 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1755 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1758 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1759 unless dst_type is a forward declaration and src_type is a struct,
1760 union, or enum (i.e. the definition of the previous forward decl).
1762 We also allow addition in the opposite order (addition of a forward when a
1763 struct, union, or enum already exists), which is a NOP and returns the
1764 already-present struct, union, or enum. */
1766 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1768 if (kind
== CTF_K_FORWARD
1769 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1770 || dst_kind
== CTF_K_UNION
))
1772 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1776 if (dst_kind
!= CTF_K_FORWARD
1777 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1778 && kind
!= CTF_K_UNION
))
1780 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1781 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1782 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1786 /* We take special action for an integer, float, or slice since it is
1787 described not only by its name but also its encoding. For integers,
1788 bit-fields exploit this degeneracy. */
1790 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1792 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1793 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1795 if (dst_type
!= CTF_ERR
)
1797 ctf_file_t
*fp
= dst_fp
;
1799 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1802 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1803 return CTF_ERR
; /* errno set for us. */
1805 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1807 /* The type that we found in the hash is also root-visible. If
1808 the two types match then use the existing one; otherwise,
1809 declare a conflict. Note: slices are not certain to match
1810 even if there is no conflict: we must check the contained type
1813 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1815 if (kind
!= CTF_K_SLICE
)
1817 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1823 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1828 /* We found a non-root-visible type in the hash. If its encoding
1829 is the same, we can reuse it, unless it is a slice. */
1831 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1833 if (kind
!= CTF_K_SLICE
)
1835 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1843 src
.ctb_file
= src_fp
;
1844 src
.ctb_type
= src_type
;
1847 dst
.ctb_file
= dst_fp
;
1848 dst
.ctb_type
= dst_type
;
1851 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1852 a new type with the same properties as src_type to dst_fp. If dst_type is
1853 not CTF_ERR, then we verify that dst_type has the same attributes as
1854 src_type. We recurse for embedded references. Before we start, we note
1855 that we are processing this type, to prevent infinite recursion: we do not
1856 re-process any type that appears in this list. The list is emptied
1857 wholesale at the end of processing everything in this recursive stack. */
1859 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1860 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1861 return ctf_set_errno (dst_fp
, ENOMEM
);
1866 /* If we found a match we will have either returned it or declared a
1868 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1872 /* If we found a match we will have either returned it or declared a
1874 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1878 /* We have checked for conflicting encodings: now try to add the
1880 src_type
= ctf_type_reference (src_fp
, src_type
);
1881 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1884 if (src_type
== CTF_ERR
)
1885 return CTF_ERR
; /* errno is set for us. */
1887 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1891 case CTF_K_VOLATILE
:
1893 case CTF_K_RESTRICT
:
1894 src_type
= ctf_type_reference (src_fp
, src_type
);
1895 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1898 if (src_type
== CTF_ERR
)
1899 return CTF_ERR
; /* errno is set for us. */
1901 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1905 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1906 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1908 src_ar
.ctr_contents
=
1909 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1911 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1914 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1916 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1917 return CTF_ERR
; /* errno is set for us. */
1919 if (dst_type
!= CTF_ERR
)
1921 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1922 return CTF_ERR
; /* errno is set for us. */
1924 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1926 ctf_dprintf ("Conflict for type %s against ID %lx: "
1927 "array info differs, old %lx/%lx/%x; "
1928 "new: %lx/%lx/%x\n", name
, dst_type
,
1929 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1930 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1931 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1932 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1936 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1939 case CTF_K_FUNCTION
:
1940 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1946 if (ctc
.ctc_return
== CTF_ERR
)
1947 return CTF_ERR
; /* errno is set for us. */
1949 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1961 /* Technically to match a struct or union we need to check both
1962 ways (src members vs. dst, dst members vs. src) but we make
1963 this more optimal by only checking src vs. dst and comparing
1964 the total size of the structure (which we must do anyway)
1965 which covers the possibility of dst members not in src.
1966 This optimization can be defeated for unions, but is so
1967 pathological as to render it irrelevant for our purposes. */
1969 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1970 && dst_kind
!= CTF_K_FORWARD
)
1972 if (ctf_type_size (src_fp
, src_type
) !=
1973 ctf_type_size (dst_fp
, dst_type
))
1975 ctf_dprintf ("Conflict for type %s against ID %lx: "
1976 "union size differs, old %li, new %li\n",
1978 (long) ctf_type_size (src_fp
, src_type
),
1979 (long) ctf_type_size (dst_fp
, dst_type
));
1980 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1983 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1985 ctf_dprintf ("Conflict for type %s against ID %lx: "
1986 "members differ, see above\n", name
, dst_type
);
1987 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1993 /* Unlike the other cases, copying structs and unions is done
1994 manually so as to avoid repeated lookups in ctf_add_member
1995 and to ensure the exact same member offsets as in src_type. */
1997 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1998 if (dst_type
== CTF_ERR
)
1999 return CTF_ERR
; /* errno is set for us. */
2001 dst
.ctb_type
= dst_type
;
2004 /* Pre-emptively add this struct to the type mapping so that
2005 structures that refer to themselves work. */
2006 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2008 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2009 errs
++; /* Increment errs and fail at bottom of case. */
2011 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2012 return CTF_ERR
; /* errno is set for us. */
2014 size
= (size_t) ssize
;
2015 if (size
> CTF_MAX_SIZE
)
2017 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2018 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2019 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2022 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2024 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2026 /* Make a final pass through the members changing each dmd_type (a
2027 src_fp type) to an equivalent type in dst_fp. We pass through all
2028 members, leaving any that fail set to CTF_ERR, unless they fail
2029 because they are marking a member of type not representable in this
2030 version of CTF, in which case we just want to silently omit them:
2031 no consumer can do anything with them anyway. */
2032 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2033 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2035 ctf_file_t
*dst
= dst_fp
;
2038 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2041 if ((dmd
->dmd_type
=
2042 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2043 proc_tracking_fp
)) == CTF_ERR
)
2045 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2050 dmd
->dmd_type
= memb_type
;
2054 return CTF_ERR
; /* errno is set for us. */
2059 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2060 && dst_kind
!= CTF_K_FORWARD
)
2062 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2063 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2065 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2066 "members differ, see above\n", name
, dst_type
);
2067 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2072 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2073 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2074 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2075 return CTF_ERR
; /* errno is set for us */
2080 if (dst_type
== CTF_ERR
)
2081 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2085 src_type
= ctf_type_reference (src_fp
, src_type
);
2086 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2089 if (src_type
== CTF_ERR
)
2090 return CTF_ERR
; /* errno is set for us. */
2092 /* If dst_type is not CTF_ERR at this point, we should check if
2093 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2094 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2095 that vary based on things like if 32-bit then pid_t is int otherwise
2096 long. We therefore omit this check and assume that if the identically
2097 named typedef already exists in dst_fp, it is correct or
2100 if (dst_type
== CTF_ERR
)
2101 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2106 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2109 if (dst_type
!= CTF_ERR
)
2110 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2115 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2119 if (!src_fp
->ctf_add_processing
)
2120 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2121 ctf_hash_eq_integer
,
2124 /* We store the hash on the source, because it contains only source type IDs:
2125 but callers will invariably expect errors to appear on the dest. */
2126 if (!src_fp
->ctf_add_processing
)
2127 return (ctf_set_errno (dst_fp
, ENOMEM
));
2129 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2130 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2135 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2137 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2139 const unsigned char *buf
;
2143 resid
= sizeof (ctf_header_t
);
2144 buf
= (unsigned char *) fp
->ctf_header
;
2147 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2148 return (ctf_set_errno (fp
, errno
));
2153 resid
= fp
->ctf_size
;
2157 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2158 return (ctf_set_errno (fp
, errno
));
2166 /* Compress the specified CTF data stream and write it to the specified file
2169 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2174 ctf_header_t
*hp
= &h
;
2175 ssize_t header_len
= sizeof (ctf_header_t
);
2176 ssize_t compress_len
;
2181 if (ctf_serialize (fp
) < 0)
2182 return -1; /* errno is set for us. */
2184 memcpy (hp
, fp
->ctf_header
, header_len
);
2185 hp
->cth_flags
|= CTF_F_COMPRESS
;
2186 compress_len
= compressBound (fp
->ctf_size
);
2188 if ((buf
= malloc (compress_len
)) == NULL
)
2189 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2191 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2192 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2194 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2195 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2199 while (header_len
> 0)
2201 if ((len
= write (fd
, hp
, header_len
)) < 0)
2203 err
= ctf_set_errno (fp
, errno
);
2211 while (compress_len
> 0)
2213 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2215 err
= ctf_set_errno (fp
, errno
);
2218 compress_len
-= len
;
2227 /* Optionally compress the specified CTF data stream and return it as a new
2228 dynamically-allocated string. */
2230 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2235 ssize_t header_len
= sizeof (ctf_header_t
);
2236 ssize_t compress_len
;
2239 if (ctf_serialize (fp
) < 0)
2240 return NULL
; /* errno is set for us. */
2242 compress_len
= compressBound (fp
->ctf_size
);
2243 if (fp
->ctf_size
< threshold
)
2244 compress_len
= fp
->ctf_size
;
2245 if ((buf
= malloc (compress_len
2246 + sizeof (struct ctf_header
))) == NULL
)
2248 ctf_set_errno (fp
, ENOMEM
);
2252 hp
= (ctf_header_t
*) buf
;
2253 memcpy (hp
, fp
->ctf_header
, header_len
);
2254 bp
= buf
+ sizeof (struct ctf_header
);
2255 *size
= sizeof (struct ctf_header
);
2257 if (fp
->ctf_size
< threshold
)
2259 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2260 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2261 *size
+= fp
->ctf_size
;
2265 hp
->cth_flags
|= CTF_F_COMPRESS
;
2266 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2267 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2269 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2270 ctf_set_errno (fp
, ECTF_COMPRESS
);
2274 *size
+= compress_len
;
2279 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2281 ctf_write (ctf_file_t
*fp
, int fd
)
2283 const unsigned char *buf
;
2287 if (ctf_serialize (fp
) < 0)
2288 return -1; /* errno is set for us. */
2290 resid
= sizeof (ctf_header_t
);
2291 buf
= (unsigned char *) fp
->ctf_header
;
2294 if ((len
= write (fd
, buf
, resid
)) <= 0)
2295 return (ctf_set_errno (fp
, errno
));
2300 resid
= fp
->ctf_size
;
2304 if ((len
= write (fd
, buf
, resid
)) <= 0)
2305 return (ctf_set_errno (fp
, errno
));