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
;
549 nfp
->ctf_dedup_atoms
= fp
->ctf_dedup_atoms
;
550 nfp
->ctf_dedup_atoms_alloc
= fp
->ctf_dedup_atoms_alloc
;
551 memcpy (&nfp
->ctf_dedup
, &fp
->ctf_dedup
, sizeof (fp
->ctf_dedup
));
553 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
555 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
556 nfp
->ctf_structs
= fp
->ctf_structs
;
557 nfp
->ctf_unions
= fp
->ctf_unions
;
558 nfp
->ctf_enums
= fp
->ctf_enums
;
559 nfp
->ctf_names
= fp
->ctf_names
;
561 fp
->ctf_dthash
= NULL
;
562 ctf_str_free_atoms (nfp
);
563 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
564 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
565 fp
->ctf_str_atoms
= NULL
;
566 fp
->ctf_prov_strtab
= NULL
;
567 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
568 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
569 fp
->ctf_add_processing
= NULL
;
570 fp
->ctf_ptrtab
= NULL
;
571 fp
->ctf_link_inputs
= NULL
;
572 fp
->ctf_link_outputs
= NULL
;
573 fp
->ctf_syn_ext_strtab
= NULL
;
574 fp
->ctf_link_in_cu_mapping
= NULL
;
575 fp
->ctf_link_out_cu_mapping
= NULL
;
576 fp
->ctf_link_type_mapping
= NULL
;
577 fp
->ctf_dedup_atoms
= NULL
;
578 fp
->ctf_dedup_atoms_alloc
= NULL
;
579 fp
->ctf_parent_unreffed
= 1;
581 fp
->ctf_dvhash
= NULL
;
582 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
583 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
584 memset (&fp
->ctf_dedup
, 0, sizeof (fp
->ctf_dedup
));
585 fp
->ctf_structs
.ctn_writable
= NULL
;
586 fp
->ctf_unions
.ctn_writable
= NULL
;
587 fp
->ctf_enums
.ctn_writable
= NULL
;
588 fp
->ctf_names
.ctn_writable
= NULL
;
590 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
591 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
592 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
594 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
595 ctf_file_close (nfp
);
601 ctf_name_table (ctf_file_t
*fp
, int kind
)
606 return &fp
->ctf_structs
;
608 return &fp
->ctf_unions
;
610 return &fp
->ctf_enums
;
612 return &fp
->ctf_names
;
617 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
620 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
623 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
624 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
626 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
627 (char *) name
, (void *) dtd
->dtd_type
) < 0)
629 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
633 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
638 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
640 ctf_dmdef_t
*dmd
, *nmd
;
641 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
642 int name_kind
= kind
;
645 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
652 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
653 dmd
!= NULL
; dmd
= nmd
)
655 if (dmd
->dmd_name
!= NULL
)
656 free (dmd
->dmd_name
);
657 nmd
= ctf_list_next (dmd
);
662 free (dtd
->dtd_u
.dtu_argv
);
665 name_kind
= dtd
->dtd_data
.ctt_type
;
669 if (dtd
->dtd_data
.ctt_name
670 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
671 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
673 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
675 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
678 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
683 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
685 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
689 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
693 if (!(fp
->ctf_flags
& LCTF_RDWR
))
696 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
699 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
701 if ((unsigned long) idx
<= fp
->ctf_typemax
)
702 return ctf_dtd_lookup (fp
, id
);
707 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
709 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
711 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
716 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
718 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
719 free (dvd
->dvd_name
);
721 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
726 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
728 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
731 /* Discard all of the dynamic type definitions and variable definitions that
732 have been added to the container since the last call to ctf_update(). We
733 locate such types by scanning the dtd list and deleting elements that have
734 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
735 by scanning the variable list and deleting elements that have update IDs
736 equal to the current value of the last-update snapshot count (indicating that
737 they were added after the most recent call to ctf_update()). */
739 ctf_discard (ctf_file_t
*fp
)
741 ctf_snapshot_id_t last_update
=
743 fp
->ctf_snapshot_lu
+ 1 };
745 /* Update required? */
746 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
749 return (ctf_rollback (fp
, last_update
));
753 ctf_snapshot (ctf_file_t
*fp
)
755 ctf_snapshot_id_t snapid
;
756 snapid
.dtd_id
= fp
->ctf_typemax
;
757 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
761 /* Like ctf_discard(), only discards everything after a particular ID. */
763 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
765 ctf_dtdef_t
*dtd
, *ntd
;
766 ctf_dvdef_t
*dvd
, *nvd
;
768 if (!(fp
->ctf_flags
& LCTF_RDWR
))
769 return (ctf_set_errno (fp
, ECTF_RDONLY
));
771 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
772 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
774 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
779 ntd
= ctf_list_next (dtd
);
781 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
784 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
785 if (kind
== CTF_K_FORWARD
)
786 kind
= dtd
->dtd_data
.ctt_type
;
788 if (dtd
->dtd_data
.ctt_name
789 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
790 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
792 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
794 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
797 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
798 ctf_dtd_delete (fp
, dtd
);
801 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
803 nvd
= ctf_list_next (dvd
);
805 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
808 ctf_dvd_delete (fp
, dvd
);
811 fp
->ctf_typemax
= id
.dtd_id
;
812 fp
->ctf_snapshots
= id
.snapshot_id
;
814 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
815 fp
->ctf_flags
&= ~LCTF_DIRTY
;
821 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
827 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
828 return (ctf_set_errno (fp
, EINVAL
));
830 if (!(fp
->ctf_flags
& LCTF_RDWR
))
831 return (ctf_set_errno (fp
, ECTF_RDONLY
));
833 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
834 return (ctf_set_errno (fp
, ECTF_FULL
));
836 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
837 return (ctf_set_errno (fp
, ECTF_FULL
));
839 /* Make sure ptrtab always grows to be big enough for all types. */
840 if (ctf_grow_ptrtab (fp
) < 0)
841 return CTF_ERR
; /* errno is set for us. */
843 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
844 return (ctf_set_errno (fp
, EAGAIN
));
846 type
= ++fp
->ctf_typemax
;
847 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
849 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
850 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
851 dtd
->dtd_type
= type
;
853 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
856 return (ctf_set_errno (fp
, EAGAIN
));
859 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
862 return CTF_ERR
; /* errno is set for us. */
864 fp
->ctf_flags
|= LCTF_DIRTY
;
870 /* When encoding integer sizes, we want to convert a byte count in the range
871 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
872 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
888 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
889 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
895 return (ctf_set_errno (fp
, EINVAL
));
897 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
898 return CTF_ERR
; /* errno is set for us. */
900 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
901 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
903 dtd
->dtd_u
.dtu_enc
= *ep
;
909 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
913 ctf_file_t
*tmp
= fp
;
914 int child
= fp
->ctf_flags
& LCTF_CHILD
;
916 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
917 return (ctf_set_errno (fp
, EINVAL
));
919 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
920 return CTF_ERR
; /* errno is set for us. */
922 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
923 return CTF_ERR
; /* errno is set for us. */
925 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
926 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
928 if (kind
!= CTF_K_POINTER
)
931 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
932 type and (if an anonymous typedef node is being pointed at) the type that
933 points at too. Note that ctf_typemax is at this point one higher than we
934 want to check against, because it's just been incremented for the addition
937 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
938 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
940 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
941 && ref_idx
< fp
->ctf_typemax
)
943 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
945 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
948 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
949 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
950 && refref_idx
< fp
->ctf_typemax
)
951 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
958 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
959 const ctf_encoding_t
*ep
)
962 ctf_id_t resolved_ref
= ref
;
965 const ctf_type_t
*tp
;
966 ctf_file_t
*tmp
= fp
;
969 return (ctf_set_errno (fp
, EINVAL
));
971 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
972 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
974 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
975 return (ctf_set_errno (fp
, EINVAL
));
977 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
978 return CTF_ERR
; /* errno is set for us. */
980 /* Make sure we ultimately point to an integral type. We also allow slices to
981 point to the unimplemented type, for now, because the compiler can emit
982 such slices, though they're not very much use. */
984 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
985 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
987 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
990 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
992 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
993 return CTF_ERR
; /* errno is set for us. */
995 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
996 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
998 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
999 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
1000 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
1006 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
1007 const char *name
, const ctf_encoding_t
*ep
)
1009 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1013 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1014 const char *name
, const ctf_encoding_t
*ep
)
1016 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1020 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1022 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1026 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1030 ctf_file_t
*tmp
= fp
;
1033 return (ctf_set_errno (fp
, EINVAL
));
1035 if (arp
->ctr_contents
!= 0
1036 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1037 return CTF_ERR
; /* errno is set for us. */
1040 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1041 return CTF_ERR
; /* errno is set for us. */
1043 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1044 return CTF_ERR
; /* errno is set for us. */
1046 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1047 dtd
->dtd_data
.ctt_size
= 0;
1048 dtd
->dtd_u
.dtu_arr
= *arp
;
1054 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1056 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1058 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1059 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1062 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1063 return (ctf_set_errno (fp
, ECTF_BADID
));
1065 fp
->ctf_flags
|= LCTF_DIRTY
;
1066 dtd
->dtd_u
.dtu_arr
= *arp
;
1072 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1073 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1078 uint32_t *vdat
= NULL
;
1079 ctf_file_t
*tmp
= fp
;
1082 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1083 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1084 return (ctf_set_errno (fp
, EINVAL
));
1086 vlen
= ctc
->ctc_argc
;
1087 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1088 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1090 if (ctc
->ctc_return
!= 0
1091 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1092 return CTF_ERR
; /* errno is set for us. */
1094 if (vlen
> CTF_MAX_VLEN
)
1095 return (ctf_set_errno (fp
, EOVERFLOW
));
1097 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1098 return (ctf_set_errno (fp
, EAGAIN
));
1100 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1103 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1106 return CTF_ERR
; /* errno is set for us. */
1108 vdat
[i
] = (uint32_t) argv
[i
];
1111 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1115 return CTF_ERR
; /* errno is set for us. */
1118 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1119 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1121 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1122 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1123 dtd
->dtd_u
.dtu_argv
= vdat
;
1129 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1135 /* Promote root-visible forwards to structs. */
1137 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1139 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1140 dtd
= ctf_dtd_lookup (fp
, type
);
1141 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1143 return CTF_ERR
; /* errno is set for us. */
1145 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1147 if (size
> CTF_MAX_SIZE
)
1149 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1150 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1151 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1154 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1160 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1162 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1166 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1172 /* Promote root-visible forwards to unions. */
1174 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1176 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1177 dtd
= ctf_dtd_lookup (fp
, type
);
1178 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1180 return CTF_ERR
; /* errno is set for us */
1182 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1184 if (size
> CTF_MAX_SIZE
)
1186 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1187 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1188 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1191 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1197 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1199 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1203 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1208 /* Promote root-visible forwards to enums. */
1210 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1212 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1213 dtd
= ctf_dtd_lookup (fp
, type
);
1214 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1216 return CTF_ERR
; /* errno is set for us. */
1218 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1219 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1225 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1226 const ctf_encoding_t
*ep
)
1230 /* First, create the enum if need be, using most of the same machinery as
1231 ctf_add_enum(), to ensure that we do not allow things past that are not
1232 enums or forwards to them. (This includes other slices: you cannot slice a
1233 slice, which would be a useless thing to do anyway.) */
1236 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1240 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1241 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1242 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1244 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1245 return CTF_ERR
; /* errno is set for us. */
1247 /* Now attach a suitable slice to it. */
1249 return ctf_add_slice (fp
, flag
, type
, ep
);
1253 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1259 if (!ctf_forwardable_kind (kind
))
1260 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1262 /* If the type is already defined or exists as a forward tag, just
1263 return the ctf_id_t of the existing definition. */
1266 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1271 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1272 return CTF_ERR
; /* errno is set for us. */
1274 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1275 dtd
->dtd_data
.ctt_type
= kind
;
1281 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1286 ctf_file_t
*tmp
= fp
;
1288 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1289 return (ctf_set_errno (fp
, EINVAL
));
1291 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1292 return CTF_ERR
; /* errno is set for us. */
1294 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1296 return CTF_ERR
; /* errno is set for us. */
1298 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1299 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1305 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1307 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1311 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1313 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1317 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1319 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1323 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1326 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1329 uint32_t kind
, vlen
, root
;
1333 return (ctf_set_errno (fp
, EINVAL
));
1335 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1336 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1339 return (ctf_set_errno (fp
, ECTF_BADID
));
1341 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1342 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1343 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1345 if (kind
!= CTF_K_ENUM
)
1346 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1348 if (vlen
== CTF_MAX_VLEN
)
1349 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1351 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1352 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1354 if (strcmp (dmd
->dmd_name
, name
) == 0)
1355 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1358 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1359 return (ctf_set_errno (fp
, EAGAIN
));
1361 if ((s
= strdup (name
)) == NULL
)
1364 return (ctf_set_errno (fp
, EAGAIN
));
1368 dmd
->dmd_type
= CTF_ERR
;
1369 dmd
->dmd_offset
= 0;
1370 dmd
->dmd_value
= value
;
1372 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1373 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1375 fp
->ctf_flags
|= LCTF_DIRTY
;
1381 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1382 ctf_id_t type
, unsigned long bit_offset
)
1384 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1387 ssize_t msize
, malign
, ssize
;
1388 uint32_t kind
, vlen
, root
;
1391 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1392 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1395 return (ctf_set_errno (fp
, ECTF_BADID
));
1397 if (name
!= NULL
&& name
[0] == '\0')
1400 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1401 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1402 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1404 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1405 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1407 if (vlen
== CTF_MAX_VLEN
)
1408 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1412 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1413 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1415 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1416 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1420 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1421 (malign
= ctf_type_align (fp
, type
)) < 0)
1423 /* The unimplemented type, and any type that resolves to it, has no size
1424 and no alignment: it can correspond to any number of compiler-inserted
1427 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1431 ctf_set_errno (fp
, 0);
1434 return -1; /* errno is set for us. */
1437 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1438 return (ctf_set_errno (fp
, EAGAIN
));
1440 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1443 return (ctf_set_errno (fp
, EAGAIN
));
1447 dmd
->dmd_type
= type
;
1448 dmd
->dmd_value
= -1;
1450 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1452 if (bit_offset
== (unsigned long) - 1)
1454 /* Natural alignment. */
1456 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1457 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1458 size_t off
= lmd
->dmd_offset
;
1460 ctf_encoding_t linfo
;
1463 /* Propagate any error from ctf_type_resolve. If the last member was
1464 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1465 cannot insert right after such a member without explicit offset
1466 specification, because its alignment and size is not known. */
1467 if (ltype
== CTF_ERR
)
1470 return -1; /* errno is set for us. */
1473 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1474 off
+= linfo
.cte_bits
;
1475 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1476 off
+= lsize
* CHAR_BIT
;
1478 /* Round up the offset of the end of the last member to
1479 the next byte boundary, convert 'off' to bytes, and
1480 then round it up again to the next multiple of the
1481 alignment required by the new member. Finally,
1482 convert back to bits and store the result in
1483 dmd_offset. Technically we could do more efficient
1484 packing if the new member is a bit-field, but we're
1485 the "compiler" and ANSI says we can do as we choose. */
1487 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1488 off
= roundup (off
, MAX (malign
, 1));
1489 dmd
->dmd_offset
= off
* CHAR_BIT
;
1490 ssize
= off
+ msize
;
1494 /* Specified offset in bits. */
1496 dmd
->dmd_offset
= bit_offset
;
1497 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1498 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1503 dmd
->dmd_offset
= 0;
1504 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1505 ssize
= MAX (ssize
, msize
);
1508 if ((size_t) ssize
> CTF_MAX_SIZE
)
1510 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1511 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1512 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1515 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1517 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1518 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1520 fp
->ctf_flags
|= LCTF_DIRTY
;
1525 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1526 ctf_id_t type
, unsigned long bit_offset
,
1527 const ctf_encoding_t encoding
)
1529 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1530 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1533 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1534 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1536 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1537 return -1; /* errno is set for us. */
1539 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1543 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1546 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1550 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1553 ctf_file_t
*tmp
= fp
;
1555 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1556 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1558 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1559 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1561 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1562 return -1; /* errno is set for us. */
1564 /* Make sure this type is representable. */
1565 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1566 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1569 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1570 return (ctf_set_errno (fp
, EAGAIN
));
1572 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1575 return (ctf_set_errno (fp
, EAGAIN
));
1577 dvd
->dvd_type
= ref
;
1578 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1580 if (ctf_dvd_insert (fp
, dvd
) < 0)
1582 free (dvd
->dvd_name
);
1584 return -1; /* errno is set for us. */
1587 fp
->ctf_flags
|= LCTF_DIRTY
;
1592 enumcmp (const char *name
, int value
, void *arg
)
1594 ctf_bundle_t
*ctb
= arg
;
1597 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1599 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1600 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1603 if (value
!= bvalue
)
1605 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1613 enumadd (const char *name
, int value
, void *arg
)
1615 ctf_bundle_t
*ctb
= arg
;
1617 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1622 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1625 ctf_bundle_t
*ctb
= arg
;
1628 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1633 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1635 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1636 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1639 if (ctm
.ctm_offset
!= offset
)
1641 ctf_dprintf ("Conflict due to member %s offset change: "
1642 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1649 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1651 ctf_bundle_t
*ctb
= arg
;
1655 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1656 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1658 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1661 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1664 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1665 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1667 dmd
->dmd_type
= type
;
1668 dmd
->dmd_offset
= offset
;
1669 dmd
->dmd_value
= -1;
1671 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1673 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1677 /* The ctf_add_type routine is used to copy a type from a source CTF container
1678 to a dynamic destination container. This routine operates recursively by
1679 following the source type's links and embedded member types. If the
1680 destination container already contains a named type which has the same
1681 attributes, then we succeed and return this type but no changes occur. */
1683 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1684 ctf_file_t
*proc_tracking_fp
)
1686 ctf_id_t dst_type
= CTF_ERR
;
1687 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1688 ctf_file_t
*tmp_fp
= dst_fp
;
1692 uint32_t kind
, forward_kind
, flag
, vlen
;
1694 const ctf_type_t
*src_tp
, *dst_tp
;
1695 ctf_bundle_t src
, dst
;
1696 ctf_encoding_t src_en
, dst_en
;
1697 ctf_arinfo_t src_ar
, dst_ar
;
1701 ctf_id_t orig_src_type
= src_type
;
1703 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1704 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1706 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1707 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1709 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1710 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1711 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1713 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1714 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1715 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1716 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1718 /* If this is a type we are currently in the middle of adding, hand it
1719 straight back. (This lets us handle self-referential structures without
1720 considering forwards and empty structures the same as their completed
1723 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1727 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1728 (void *) (uintptr_t) src_type
))
1731 /* If this type has already been added from this container, and is the same
1732 kind and (if a struct or union) has the same number of members, hand it
1735 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1737 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1738 || kind
== CTF_K_ENUM
)
1740 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1741 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1749 forward_kind
= kind
;
1750 if (kind
== CTF_K_FORWARD
)
1751 forward_kind
= src_tp
->ctt_type
;
1753 /* If the source type has a name and is a root type (visible at the
1754 top-level scope), lookup the name in the destination container and
1755 verify that it is of the same kind before we do anything else. */
1757 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1758 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1761 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1764 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1765 unless dst_type is a forward declaration and src_type is a struct,
1766 union, or enum (i.e. the definition of the previous forward decl).
1768 We also allow addition in the opposite order (addition of a forward when a
1769 struct, union, or enum already exists), which is a NOP and returns the
1770 already-present struct, union, or enum. */
1772 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1774 if (kind
== CTF_K_FORWARD
1775 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1776 || dst_kind
== CTF_K_UNION
))
1778 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1782 if (dst_kind
!= CTF_K_FORWARD
1783 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1784 && kind
!= CTF_K_UNION
))
1786 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1787 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1788 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1792 /* We take special action for an integer, float, or slice since it is
1793 described not only by its name but also its encoding. For integers,
1794 bit-fields exploit this degeneracy. */
1796 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1798 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1799 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1801 if (dst_type
!= CTF_ERR
)
1803 ctf_file_t
*fp
= dst_fp
;
1805 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1808 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1809 return CTF_ERR
; /* errno set for us. */
1811 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1813 /* The type that we found in the hash is also root-visible. If
1814 the two types match then use the existing one; otherwise,
1815 declare a conflict. Note: slices are not certain to match
1816 even if there is no conflict: we must check the contained type
1819 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1821 if (kind
!= CTF_K_SLICE
)
1823 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1829 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1834 /* We found a non-root-visible type in the hash. If its encoding
1835 is the same, we can reuse it, unless it is a slice. */
1837 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1839 if (kind
!= CTF_K_SLICE
)
1841 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1849 src
.ctb_file
= src_fp
;
1850 src
.ctb_type
= src_type
;
1853 dst
.ctb_file
= dst_fp
;
1854 dst
.ctb_type
= dst_type
;
1857 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1858 a new type with the same properties as src_type to dst_fp. If dst_type is
1859 not CTF_ERR, then we verify that dst_type has the same attributes as
1860 src_type. We recurse for embedded references. Before we start, we note
1861 that we are processing this type, to prevent infinite recursion: we do not
1862 re-process any type that appears in this list. The list is emptied
1863 wholesale at the end of processing everything in this recursive stack. */
1865 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1866 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1867 return ctf_set_errno (dst_fp
, ENOMEM
);
1872 /* If we found a match we will have either returned it or declared a
1874 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1878 /* If we found a match we will have either returned it or declared a
1880 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1884 /* We have checked for conflicting encodings: now try to add the
1886 src_type
= ctf_type_reference (src_fp
, src_type
);
1887 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1890 if (src_type
== CTF_ERR
)
1891 return CTF_ERR
; /* errno is set for us. */
1893 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1897 case CTF_K_VOLATILE
:
1899 case CTF_K_RESTRICT
:
1900 src_type
= ctf_type_reference (src_fp
, src_type
);
1901 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1904 if (src_type
== CTF_ERR
)
1905 return CTF_ERR
; /* errno is set for us. */
1907 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1911 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1912 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1914 src_ar
.ctr_contents
=
1915 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1917 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1920 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1922 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1923 return CTF_ERR
; /* errno is set for us. */
1925 if (dst_type
!= CTF_ERR
)
1927 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1928 return CTF_ERR
; /* errno is set for us. */
1930 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1932 ctf_dprintf ("Conflict for type %s against ID %lx: "
1933 "array info differs, old %lx/%lx/%x; "
1934 "new: %lx/%lx/%x\n", name
, dst_type
,
1935 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1936 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1937 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1938 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1942 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1945 case CTF_K_FUNCTION
:
1946 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1952 if (ctc
.ctc_return
== CTF_ERR
)
1953 return CTF_ERR
; /* errno is set for us. */
1955 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1967 /* Technically to match a struct or union we need to check both
1968 ways (src members vs. dst, dst members vs. src) but we make
1969 this more optimal by only checking src vs. dst and comparing
1970 the total size of the structure (which we must do anyway)
1971 which covers the possibility of dst members not in src.
1972 This optimization can be defeated for unions, but is so
1973 pathological as to render it irrelevant for our purposes. */
1975 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1976 && dst_kind
!= CTF_K_FORWARD
)
1978 if (ctf_type_size (src_fp
, src_type
) !=
1979 ctf_type_size (dst_fp
, dst_type
))
1981 ctf_dprintf ("Conflict for type %s against ID %lx: "
1982 "union size differs, old %li, new %li\n",
1984 (long) ctf_type_size (src_fp
, src_type
),
1985 (long) ctf_type_size (dst_fp
, dst_type
));
1986 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1989 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1991 ctf_dprintf ("Conflict for type %s against ID %lx: "
1992 "members differ, see above\n", name
, dst_type
);
1993 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1999 /* Unlike the other cases, copying structs and unions is done
2000 manually so as to avoid repeated lookups in ctf_add_member
2001 and to ensure the exact same member offsets as in src_type. */
2003 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2004 if (dst_type
== CTF_ERR
)
2005 return CTF_ERR
; /* errno is set for us. */
2007 dst
.ctb_type
= dst_type
;
2010 /* Pre-emptively add this struct to the type mapping so that
2011 structures that refer to themselves work. */
2012 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2014 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2015 errs
++; /* Increment errs and fail at bottom of case. */
2017 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2018 return CTF_ERR
; /* errno is set for us. */
2020 size
= (size_t) ssize
;
2021 if (size
> CTF_MAX_SIZE
)
2023 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2024 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2025 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2028 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2030 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2032 /* Make a final pass through the members changing each dmd_type (a
2033 src_fp type) to an equivalent type in dst_fp. We pass through all
2034 members, leaving any that fail set to CTF_ERR, unless they fail
2035 because they are marking a member of type not representable in this
2036 version of CTF, in which case we just want to silently omit them:
2037 no consumer can do anything with them anyway. */
2038 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2039 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2041 ctf_file_t
*dst
= dst_fp
;
2044 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2047 if ((dmd
->dmd_type
=
2048 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2049 proc_tracking_fp
)) == CTF_ERR
)
2051 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2056 dmd
->dmd_type
= memb_type
;
2060 return CTF_ERR
; /* errno is set for us. */
2065 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2066 && dst_kind
!= CTF_K_FORWARD
)
2068 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2069 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2071 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2072 "members differ, see above\n", name
, dst_type
);
2073 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2078 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2079 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2080 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2081 return CTF_ERR
; /* errno is set for us */
2086 if (dst_type
== CTF_ERR
)
2087 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2091 src_type
= ctf_type_reference (src_fp
, src_type
);
2092 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2095 if (src_type
== CTF_ERR
)
2096 return CTF_ERR
; /* errno is set for us. */
2098 /* If dst_type is not CTF_ERR at this point, we should check if
2099 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2100 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2101 that vary based on things like if 32-bit then pid_t is int otherwise
2102 long. We therefore omit this check and assume that if the identically
2103 named typedef already exists in dst_fp, it is correct or
2106 if (dst_type
== CTF_ERR
)
2107 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2112 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2115 if (dst_type
!= CTF_ERR
)
2116 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2121 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2125 if (!src_fp
->ctf_add_processing
)
2126 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2127 ctf_hash_eq_integer
,
2130 /* We store the hash on the source, because it contains only source type IDs:
2131 but callers will invariably expect errors to appear on the dest. */
2132 if (!src_fp
->ctf_add_processing
)
2133 return (ctf_set_errno (dst_fp
, ENOMEM
));
2135 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2136 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2141 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2143 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2145 const unsigned char *buf
;
2149 resid
= sizeof (ctf_header_t
);
2150 buf
= (unsigned char *) fp
->ctf_header
;
2153 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2154 return (ctf_set_errno (fp
, errno
));
2159 resid
= fp
->ctf_size
;
2163 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2164 return (ctf_set_errno (fp
, errno
));
2172 /* Compress the specified CTF data stream and write it to the specified file
2175 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2180 ctf_header_t
*hp
= &h
;
2181 ssize_t header_len
= sizeof (ctf_header_t
);
2182 ssize_t compress_len
;
2187 if (ctf_serialize (fp
) < 0)
2188 return -1; /* errno is set for us. */
2190 memcpy (hp
, fp
->ctf_header
, header_len
);
2191 hp
->cth_flags
|= CTF_F_COMPRESS
;
2192 compress_len
= compressBound (fp
->ctf_size
);
2194 if ((buf
= malloc (compress_len
)) == NULL
)
2195 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2197 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2198 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2200 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2201 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2205 while (header_len
> 0)
2207 if ((len
= write (fd
, hp
, header_len
)) < 0)
2209 err
= ctf_set_errno (fp
, errno
);
2217 while (compress_len
> 0)
2219 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2221 err
= ctf_set_errno (fp
, errno
);
2224 compress_len
-= len
;
2233 /* Optionally compress the specified CTF data stream and return it as a new
2234 dynamically-allocated string. */
2236 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2241 ssize_t header_len
= sizeof (ctf_header_t
);
2242 ssize_t compress_len
;
2245 if (ctf_serialize (fp
) < 0)
2246 return NULL
; /* errno is set for us. */
2248 compress_len
= compressBound (fp
->ctf_size
);
2249 if (fp
->ctf_size
< threshold
)
2250 compress_len
= fp
->ctf_size
;
2251 if ((buf
= malloc (compress_len
2252 + sizeof (struct ctf_header
))) == NULL
)
2254 ctf_set_errno (fp
, ENOMEM
);
2258 hp
= (ctf_header_t
*) buf
;
2259 memcpy (hp
, fp
->ctf_header
, header_len
);
2260 bp
= buf
+ sizeof (struct ctf_header
);
2261 *size
= sizeof (struct ctf_header
);
2263 if (fp
->ctf_size
< threshold
)
2265 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2266 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2267 *size
+= fp
->ctf_size
;
2271 hp
->cth_flags
|= CTF_F_COMPRESS
;
2272 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2273 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2275 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2276 ctf_set_errno (fp
, ECTF_COMPRESS
);
2280 *size
+= compress_len
;
2285 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2287 ctf_write (ctf_file_t
*fp
, int fd
)
2289 const unsigned char *buf
;
2293 if (ctf_serialize (fp
) < 0)
2294 return -1; /* errno is set for us. */
2296 resid
= sizeof (ctf_header_t
);
2297 buf
= (unsigned char *) fp
->ctf_header
;
2300 if ((len
= write (fd
, buf
, resid
)) <= 0)
2301 return (ctf_set_errno (fp
, errno
));
2306 resid
= fp
->ctf_size
;
2310 if ((len
= write (fd
, buf
, resid
)) <= 0)
2311 return (ctf_set_errno (fp
, errno
));