2 Copyright (C) 2019-2020 Free Software Foundation, Inc.
4 This file is part of libctf.
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
21 #include <sys/param.h>
28 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
31 /* Make sure the ptrtab has enough space for at least one more type.
33 We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
37 ctf_grow_ptrtab (ctf_file_t
*fp
)
39 size_t new_ptrtab_len
= fp
->ctf_ptrtab_len
;
41 /* We allocate one more ptrtab entry than we need, for the initial zero,
42 plus one because the caller will probably allocate a new type. */
44 if (fp
->ctf_ptrtab
== NULL
)
45 new_ptrtab_len
= 1024;
46 else if ((fp
->ctf_typemax
+ 2) > fp
->ctf_ptrtab_len
)
47 new_ptrtab_len
= fp
->ctf_ptrtab_len
* 1.25;
49 if (new_ptrtab_len
!= fp
->ctf_ptrtab_len
)
53 if ((new_ptrtab
= realloc (fp
->ctf_ptrtab
,
54 new_ptrtab_len
* sizeof (uint32_t))) == NULL
)
55 return (ctf_set_errno (fp
, ENOMEM
));
57 fp
->ctf_ptrtab
= new_ptrtab
;
58 memset (fp
->ctf_ptrtab
+ fp
->ctf_ptrtab_len
, 0,
59 (new_ptrtab_len
- fp
->ctf_ptrtab_len
) * sizeof (uint32_t));
60 fp
->ctf_ptrtab_len
= new_ptrtab_len
;
65 /* To create an empty CTF container, we just declare a zeroed header and call
66 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new container r/w
67 and initialize the dynamic members. We start assigning type IDs at 1 because
68 type ID 0 is used as a sentinel and a not-found indicator. */
71 ctf_create (int *errp
)
73 static const ctf_header_t hdr
= { .cth_preamble
= { CTF_MAGIC
, CTF_VERSION
, 0 } };
75 ctf_dynhash_t
*dthash
;
76 ctf_dynhash_t
*dvhash
;
77 ctf_dynhash_t
*structs
= NULL
, *unions
= NULL
, *enums
= NULL
, *names
= NULL
;
82 dthash
= ctf_dynhash_create (ctf_hash_integer
, ctf_hash_eq_integer
,
86 ctf_set_open_errno (errp
, EAGAIN
);
90 dvhash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
94 ctf_set_open_errno (errp
, EAGAIN
);
98 structs
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
100 unions
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
102 enums
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
104 names
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
106 if (!structs
|| !unions
|| !enums
|| !names
)
108 ctf_set_open_errno (errp
, EAGAIN
);
112 cts
.cts_name
= _CTF_SECTION
;
114 cts
.cts_size
= sizeof (hdr
);
117 if ((fp
= ctf_bufopen_internal (&cts
, NULL
, NULL
, NULL
, 1, errp
)) == NULL
)
120 fp
->ctf_structs
.ctn_writable
= structs
;
121 fp
->ctf_unions
.ctn_writable
= unions
;
122 fp
->ctf_enums
.ctn_writable
= enums
;
123 fp
->ctf_names
.ctn_writable
= names
;
124 fp
->ctf_dthash
= dthash
;
125 fp
->ctf_dvhash
= dvhash
;
127 fp
->ctf_snapshots
= 1;
128 fp
->ctf_snapshot_lu
= 0;
129 fp
->ctf_flags
|= LCTF_DIRTY
;
131 ctf_set_ctl_hashes (fp
);
132 ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
133 if (ctf_grow_ptrtab (fp
) < 0)
135 ctf_set_open_errno (errp
, ctf_errno (fp
));
143 ctf_dynhash_destroy (structs
);
144 ctf_dynhash_destroy (unions
);
145 ctf_dynhash_destroy (enums
);
146 ctf_dynhash_destroy (names
);
147 ctf_dynhash_destroy (dvhash
);
149 ctf_dynhash_destroy (dthash
);
154 static unsigned char *
155 ctf_copy_smembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
157 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
160 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
162 ctf_member_t
*copied
;
165 ctm
.ctm_type
= (uint32_t) dmd
->dmd_type
;
166 ctm
.ctm_offset
= (uint32_t) dmd
->dmd_offset
;
168 memcpy (t
, &ctm
, sizeof (ctm
));
169 copied
= (ctf_member_t
*) t
;
171 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctm_name
);
179 static unsigned char *
180 ctf_copy_lmembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
182 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
185 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
187 ctf_lmember_t
*copied
;
190 ctlm
.ctlm_type
= (uint32_t) dmd
->dmd_type
;
191 ctlm
.ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (dmd
->dmd_offset
);
192 ctlm
.ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (dmd
->dmd_offset
);
194 memcpy (t
, &ctlm
, sizeof (ctlm
));
195 copied
= (ctf_lmember_t
*) t
;
197 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctlm_name
);
205 static unsigned char *
206 ctf_copy_emembers (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
208 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
211 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
215 cte
.cte_value
= dmd
->dmd_value
;
216 memcpy (t
, &cte
, sizeof (cte
));
217 copied
= (ctf_enum_t
*) t
;
218 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->cte_name
);
225 /* Sort a newly-constructed static variable array. */
227 typedef struct ctf_sort_var_arg_cb
231 } ctf_sort_var_arg_cb_t
;
234 ctf_sort_var (const void *one_
, const void *two_
, void *arg_
)
236 const ctf_varent_t
*one
= one_
;
237 const ctf_varent_t
*two
= two_
;
238 ctf_sort_var_arg_cb_t
*arg
= arg_
;
240 return (strcmp (ctf_strraw_explicit (arg
->fp
, one
->ctv_name
, arg
->strtab
),
241 ctf_strraw_explicit (arg
->fp
, two
->ctv_name
, arg
->strtab
)));
244 /* Compatibility: just update the threshold for ctf_discard. */
246 ctf_update (ctf_file_t
*fp
)
248 if (!(fp
->ctf_flags
& LCTF_RDWR
))
249 return (ctf_set_errno (fp
, ECTF_RDONLY
));
251 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
255 /* If the specified CTF container is writable and has been modified, reload this
256 container with the updated type definitions, ready for serialization. In
257 order to make this code and the rest of libctf as simple as possible, we
258 perform updates by taking the dynamic type definitions and creating an
259 in-memory CTF file containing the definitions, and then call
260 ctf_simple_open_internal() on it. We perform one extra trick here for the
261 benefit of callers and to keep our code simple: ctf_simple_open_internal()
262 will return a new ctf_file_t, but we want to keep the fp constant for the
263 caller, so after ctf_simple_open_internal() returns, we use memcpy to swap
264 the interior of the old and new ctf_file_t's, and then free the old. */
266 ctf_serialize (ctf_file_t
*fp
)
268 ctf_file_t ofp
, *nfp
;
269 ctf_header_t hdr
, *hdrp
;
272 ctf_varent_t
*dvarents
;
273 ctf_strs_writable_t strtab
;
277 size_t buf_size
, type_size
, nvars
;
278 unsigned char *buf
, *newbuf
;
281 if (!(fp
->ctf_flags
& LCTF_RDWR
))
282 return (ctf_set_errno (fp
, ECTF_RDONLY
));
284 /* Update required? */
285 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
288 /* Fill in an initial CTF header. We will leave the label, object,
289 and function sections empty and only output a header, type section,
290 and string table. The type section begins at a 4-byte aligned
291 boundary past the CTF header itself (at relative offset zero). */
293 memset (&hdr
, 0, sizeof (hdr
));
294 hdr
.cth_magic
= CTF_MAGIC
;
295 hdr
.cth_version
= CTF_VERSION
;
297 /* Iterate through the dynamic type definition list and compute the
298 size of the CTF type section we will need to generate. */
300 for (type_size
= 0, dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
301 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
303 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
304 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
306 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
307 type_size
+= sizeof (ctf_stype_t
);
309 type_size
+= sizeof (ctf_type_t
);
315 type_size
+= sizeof (uint32_t);
318 type_size
+= sizeof (ctf_array_t
);
321 type_size
+= sizeof (ctf_slice_t
);
324 type_size
+= sizeof (uint32_t) * (vlen
+ (vlen
& 1));
328 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
329 type_size
+= sizeof (ctf_member_t
) * vlen
;
331 type_size
+= sizeof (ctf_lmember_t
) * vlen
;
334 type_size
+= sizeof (ctf_enum_t
) * vlen
;
339 /* Computing the number of entries in the CTF variable section is much
342 for (nvars
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
);
343 dvd
!= NULL
; dvd
= ctf_list_next (dvd
), nvars
++);
345 /* Compute the size of the CTF buffer we need, sans only the string table,
346 then allocate a new buffer and memcpy the finished header to the start of
347 the buffer. (We will adjust this later with strtab length info.) */
349 hdr
.cth_typeoff
= hdr
.cth_varoff
+ (nvars
* sizeof (ctf_varent_t
));
350 hdr
.cth_stroff
= hdr
.cth_typeoff
+ type_size
;
353 buf_size
= sizeof (ctf_header_t
) + hdr
.cth_stroff
+ hdr
.cth_strlen
;
355 if ((buf
= malloc (buf_size
)) == NULL
)
356 return (ctf_set_errno (fp
, EAGAIN
));
358 memcpy (buf
, &hdr
, sizeof (ctf_header_t
));
359 t
= (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_varoff
;
361 hdrp
= (ctf_header_t
*) buf
;
362 if ((fp
->ctf_flags
& LCTF_CHILD
) && (fp
->ctf_parname
!= NULL
))
363 ctf_str_add_ref (fp
, fp
->ctf_parname
, &hdrp
->cth_parname
);
364 if (fp
->ctf_cuname
!= NULL
)
365 ctf_str_add_ref (fp
, fp
->ctf_cuname
, &hdrp
->cth_cuname
);
367 /* Work over the variable list, translating everything into ctf_varent_t's and
368 prepping the string table. */
370 dvarents
= (ctf_varent_t
*) t
;
371 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
372 dvd
= ctf_list_next (dvd
), i
++)
374 ctf_varent_t
*var
= &dvarents
[i
];
376 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
377 var
->ctv_type
= (uint32_t) dvd
->dvd_type
;
381 t
+= sizeof (ctf_varent_t
) * nvars
;
383 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
385 /* We now take a final lap through the dynamic type definition list and copy
386 the appropriate type records to the output buffer, noting down the
389 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
390 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
392 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
393 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
401 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
402 len
= sizeof (ctf_stype_t
);
404 len
= sizeof (ctf_type_t
);
406 memcpy (t
, &dtd
->dtd_data
, len
);
407 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
409 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
410 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
417 if (kind
== CTF_K_INTEGER
)
419 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
420 dtd
->dtd_u
.dtu_enc
.cte_offset
,
421 dtd
->dtd_u
.dtu_enc
.cte_bits
);
425 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
426 dtd
->dtd_u
.dtu_enc
.cte_offset
,
427 dtd
->dtd_u
.dtu_enc
.cte_bits
);
429 memcpy (t
, &encoding
, sizeof (encoding
));
430 t
+= sizeof (encoding
);
434 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
435 t
+= sizeof (struct ctf_slice
);
439 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
440 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
441 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
442 memcpy (t
, &cta
, sizeof (cta
));
448 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
451 for (argc
= 0; argc
< vlen
; argc
++)
452 *argv
++ = dtd
->dtd_u
.dtu_argv
[argc
];
455 *argv
++ = 0; /* Pad to 4-byte boundary. */
457 t
= (unsigned char *) argv
;
463 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
464 t
= ctf_copy_smembers (fp
, dtd
, t
);
466 t
= ctf_copy_lmembers (fp
, dtd
, t
);
470 t
= ctf_copy_emembers (fp
, dtd
, t
);
474 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
476 /* Construct the final string table and fill out all the string refs with the
477 final offsets. Then purge the refs list, because we're about to move this
478 strtab onto the end of the buf, invalidating all the offsets. */
479 strtab
= ctf_str_write_strtab (fp
);
480 ctf_str_purge_refs (fp
);
482 if (strtab
.cts_strs
== NULL
)
485 return (ctf_set_errno (fp
, EAGAIN
));
488 /* Now the string table is constructed, we can sort the buffer of
490 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
491 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
494 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
497 free (strtab
.cts_strs
);
498 return (ctf_set_errno (fp
, EAGAIN
));
501 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
502 hdrp
= (ctf_header_t
*) buf
;
503 hdrp
->cth_strlen
= strtab
.cts_len
;
504 buf_size
+= hdrp
->cth_strlen
;
505 free (strtab
.cts_strs
);
507 /* Finally, we are ready to ctf_simple_open() the new container. If this
508 is successful, we then switch nfp and fp and free the old container. */
510 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
511 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
515 return (ctf_set_errno (fp
, err
));
518 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
520 nfp
->ctf_parent
= fp
->ctf_parent
;
521 nfp
->ctf_parent_unreffed
= fp
->ctf_parent_unreffed
;
522 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
523 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
524 if (nfp
->ctf_dynbase
== NULL
)
525 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
526 nfp
->ctf_dthash
= fp
->ctf_dthash
;
527 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
528 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
529 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
530 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
531 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
532 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
533 nfp
->ctf_specific
= fp
->ctf_specific
;
534 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
535 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
536 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
537 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
538 nfp
->ctf_errs_warnings
= fp
->ctf_errs_warnings
;
539 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
540 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
541 nfp
->ctf_link_cu_mapping
= fp
->ctf_link_cu_mapping
;
542 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
543 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
544 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
545 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
547 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
549 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
550 nfp
->ctf_structs
= fp
->ctf_structs
;
551 nfp
->ctf_unions
= fp
->ctf_unions
;
552 nfp
->ctf_enums
= fp
->ctf_enums
;
553 nfp
->ctf_names
= fp
->ctf_names
;
555 fp
->ctf_dthash
= NULL
;
556 ctf_str_free_atoms (nfp
);
557 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
558 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
559 fp
->ctf_str_atoms
= NULL
;
560 fp
->ctf_prov_strtab
= NULL
;
561 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
562 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
563 fp
->ctf_add_processing
= NULL
;
564 fp
->ctf_ptrtab
= NULL
;
565 fp
->ctf_link_inputs
= NULL
;
566 fp
->ctf_link_outputs
= NULL
;
567 fp
->ctf_syn_ext_strtab
= NULL
;
568 fp
->ctf_link_cu_mapping
= NULL
;
569 fp
->ctf_link_type_mapping
= NULL
;
570 fp
->ctf_parent_unreffed
= 1;
572 fp
->ctf_dvhash
= NULL
;
573 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
574 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
575 fp
->ctf_structs
.ctn_writable
= NULL
;
576 fp
->ctf_unions
.ctn_writable
= NULL
;
577 fp
->ctf_enums
.ctn_writable
= NULL
;
578 fp
->ctf_names
.ctn_writable
= NULL
;
580 memcpy (&ofp
, fp
, sizeof (ctf_file_t
));
581 memcpy (fp
, nfp
, sizeof (ctf_file_t
));
582 memcpy (nfp
, &ofp
, sizeof (ctf_file_t
));
584 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
585 ctf_file_close (nfp
);
591 ctf_name_table (ctf_file_t
*fp
, int kind
)
596 return &fp
->ctf_structs
;
598 return &fp
->ctf_unions
;
600 return &fp
->ctf_enums
;
602 return &fp
->ctf_names
;
607 ctf_dtd_insert (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
610 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) dtd
->dtd_type
, dtd
) < 0)
613 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
614 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
616 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
617 (char *) name
, (void *) dtd
->dtd_type
) < 0)
619 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
623 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
628 ctf_dtd_delete (ctf_file_t
*fp
, ctf_dtdef_t
*dtd
)
630 ctf_dmdef_t
*dmd
, *nmd
;
631 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
632 int name_kind
= kind
;
635 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
642 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
643 dmd
!= NULL
; dmd
= nmd
)
645 if (dmd
->dmd_name
!= NULL
)
646 free (dmd
->dmd_name
);
647 nmd
= ctf_list_next (dmd
);
652 free (dtd
->dtd_u
.dtu_argv
);
655 name_kind
= dtd
->dtd_data
.ctt_type
;
659 if (dtd
->dtd_data
.ctt_name
660 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
661 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
663 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
665 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
668 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
673 ctf_dtd_lookup (const ctf_file_t
*fp
, ctf_id_t type
)
675 return (ctf_dtdef_t
*) ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) type
);
679 ctf_dynamic_type (const ctf_file_t
*fp
, ctf_id_t id
)
683 if (!(fp
->ctf_flags
& LCTF_RDWR
))
686 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
689 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
691 if ((unsigned long) idx
<= fp
->ctf_typemax
)
692 return ctf_dtd_lookup (fp
, id
);
697 ctf_dvd_insert (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
699 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
701 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
706 ctf_dvd_delete (ctf_file_t
*fp
, ctf_dvdef_t
*dvd
)
708 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
709 free (dvd
->dvd_name
);
711 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
716 ctf_dvd_lookup (const ctf_file_t
*fp
, const char *name
)
718 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
721 /* Discard all of the dynamic type definitions and variable definitions that
722 have been added to the container since the last call to ctf_update(). We
723 locate such types by scanning the dtd list and deleting elements that have
724 type IDs greater than ctf_dtoldid, which is set by ctf_update(), above, and
725 by scanning the variable list and deleting elements that have update IDs
726 equal to the current value of the last-update snapshot count (indicating that
727 they were added after the most recent call to ctf_update()). */
729 ctf_discard (ctf_file_t
*fp
)
731 ctf_snapshot_id_t last_update
=
733 fp
->ctf_snapshot_lu
+ 1 };
735 /* Update required? */
736 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
739 return (ctf_rollback (fp
, last_update
));
743 ctf_snapshot (ctf_file_t
*fp
)
745 ctf_snapshot_id_t snapid
;
746 snapid
.dtd_id
= fp
->ctf_typemax
;
747 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
751 /* Like ctf_discard(), only discards everything after a particular ID. */
753 ctf_rollback (ctf_file_t
*fp
, ctf_snapshot_id_t id
)
755 ctf_dtdef_t
*dtd
, *ntd
;
756 ctf_dvdef_t
*dvd
, *nvd
;
758 if (!(fp
->ctf_flags
& LCTF_RDWR
))
759 return (ctf_set_errno (fp
, ECTF_RDONLY
));
761 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
762 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
764 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
769 ntd
= ctf_list_next (dtd
);
771 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
774 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
775 if (kind
== CTF_K_FORWARD
)
776 kind
= dtd
->dtd_data
.ctt_type
;
778 if (dtd
->dtd_data
.ctt_name
779 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
780 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
782 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
784 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
787 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) dtd
->dtd_type
);
788 ctf_dtd_delete (fp
, dtd
);
791 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
793 nvd
= ctf_list_next (dvd
);
795 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
798 ctf_dvd_delete (fp
, dvd
);
801 fp
->ctf_typemax
= id
.dtd_id
;
802 fp
->ctf_snapshots
= id
.snapshot_id
;
804 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
805 fp
->ctf_flags
&= ~LCTF_DIRTY
;
811 ctf_add_generic (ctf_file_t
*fp
, uint32_t flag
, const char *name
, int kind
,
817 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
818 return (ctf_set_errno (fp
, EINVAL
));
820 if (!(fp
->ctf_flags
& LCTF_RDWR
))
821 return (ctf_set_errno (fp
, ECTF_RDONLY
));
823 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
824 return (ctf_set_errno (fp
, ECTF_FULL
));
826 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
827 return (ctf_set_errno (fp
, ECTF_FULL
));
829 /* Make sure ptrtab always grows to be big enough for all types. */
830 if (ctf_grow_ptrtab (fp
) < 0)
831 return CTF_ERR
; /* errno is set for us. */
833 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
834 return (ctf_set_errno (fp
, EAGAIN
));
836 type
= ++fp
->ctf_typemax
;
837 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
839 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
840 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
841 dtd
->dtd_type
= type
;
843 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
846 return (ctf_set_errno (fp
, EAGAIN
));
849 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
852 return CTF_ERR
; /* errno is set for us. */
854 fp
->ctf_flags
|= LCTF_DIRTY
;
860 /* When encoding integer sizes, we want to convert a byte count in the range
861 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
862 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
878 ctf_add_encoded (ctf_file_t
*fp
, uint32_t flag
,
879 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
885 return (ctf_set_errno (fp
, EINVAL
));
887 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
888 return CTF_ERR
; /* errno is set for us. */
890 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
891 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
893 dtd
->dtd_u
.dtu_enc
= *ep
;
899 ctf_add_reftype (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
903 ctf_file_t
*tmp
= fp
;
904 int child
= fp
->ctf_flags
& LCTF_CHILD
;
906 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
907 return (ctf_set_errno (fp
, EINVAL
));
909 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
910 return CTF_ERR
; /* errno is set for us. */
912 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
913 return CTF_ERR
; /* errno is set for us. */
915 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
916 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
918 if (kind
!= CTF_K_POINTER
)
921 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
922 type and (if an anonymous typedef node is being pointed at) the type that
923 points at too. Note that ctf_typemax is at this point one higher than we
924 want to check against, because it's just been incremented for the addition
927 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
928 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
930 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
931 && ref_idx
< fp
->ctf_typemax
)
933 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
935 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
938 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
939 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
940 && refref_idx
< fp
->ctf_typemax
)
941 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
948 ctf_add_slice (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
,
949 const ctf_encoding_t
*ep
)
952 ctf_id_t resolved_ref
= ref
;
955 const ctf_type_t
*tp
;
956 ctf_file_t
*tmp
= fp
;
959 return (ctf_set_errno (fp
, EINVAL
));
961 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
962 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
964 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
965 return (ctf_set_errno (fp
, EINVAL
));
967 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
968 return CTF_ERR
; /* errno is set for us. */
970 /* Make sure we ultimately point to an integral type. We also allow slices to
971 point to the unimplemented type, for now, because the compiler can emit
972 such slices, though they're not very much use. */
974 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
975 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
977 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
980 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
982 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
983 return CTF_ERR
; /* errno is set for us. */
985 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
986 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
988 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
989 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
990 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
996 ctf_add_integer (ctf_file_t
*fp
, uint32_t flag
,
997 const char *name
, const ctf_encoding_t
*ep
)
999 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1003 ctf_add_float (ctf_file_t
*fp
, uint32_t flag
,
1004 const char *name
, const ctf_encoding_t
*ep
)
1006 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1010 ctf_add_pointer (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1012 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1016 ctf_add_array (ctf_file_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1020 ctf_file_t
*tmp
= fp
;
1023 return (ctf_set_errno (fp
, EINVAL
));
1025 if (arp
->ctr_contents
!= 0
1026 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1027 return CTF_ERR
; /* errno is set for us. */
1030 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1031 return CTF_ERR
; /* errno is set for us. */
1033 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1034 return CTF_ERR
; /* errno is set for us. */
1036 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1037 dtd
->dtd_data
.ctt_size
= 0;
1038 dtd
->dtd_u
.dtu_arr
= *arp
;
1044 ctf_set_array (ctf_file_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1046 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1048 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1049 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1052 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1053 return (ctf_set_errno (fp
, ECTF_BADID
));
1055 fp
->ctf_flags
|= LCTF_DIRTY
;
1056 dtd
->dtd_u
.dtu_arr
= *arp
;
1062 ctf_add_function (ctf_file_t
*fp
, uint32_t flag
,
1063 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1068 uint32_t *vdat
= NULL
;
1069 ctf_file_t
*tmp
= fp
;
1072 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1073 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1074 return (ctf_set_errno (fp
, EINVAL
));
1076 vlen
= ctc
->ctc_argc
;
1077 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1078 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1080 if (ctc
->ctc_return
!= 0
1081 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1082 return CTF_ERR
; /* errno is set for us. */
1084 if (vlen
> CTF_MAX_VLEN
)
1085 return (ctf_set_errno (fp
, EOVERFLOW
));
1087 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1088 return (ctf_set_errno (fp
, EAGAIN
));
1090 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1093 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1096 return CTF_ERR
; /* errno is set for us. */
1098 vdat
[i
] = (uint32_t) argv
[i
];
1101 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1105 return CTF_ERR
; /* errno is set for us. */
1108 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1109 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1111 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1112 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1113 dtd
->dtd_u
.dtu_argv
= vdat
;
1119 ctf_add_struct_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1125 /* Promote root-visible forwards to structs. */
1127 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1129 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1130 dtd
= ctf_dtd_lookup (fp
, type
);
1131 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1133 return CTF_ERR
; /* errno is set for us. */
1135 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1137 if (size
> CTF_MAX_SIZE
)
1139 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1140 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1141 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1144 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1150 ctf_add_struct (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1152 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1156 ctf_add_union_sized (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1162 /* Promote root-visible forwards to unions. */
1164 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1166 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1167 dtd
= ctf_dtd_lookup (fp
, type
);
1168 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1170 return CTF_ERR
; /* errno is set for us */
1172 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1174 if (size
> CTF_MAX_SIZE
)
1176 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1177 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1178 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1181 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1187 ctf_add_union (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1189 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1193 ctf_add_enum (ctf_file_t
*fp
, uint32_t flag
, const char *name
)
1198 /* Promote root-visible forwards to enums. */
1200 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1202 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1203 dtd
= ctf_dtd_lookup (fp
, type
);
1204 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1206 return CTF_ERR
; /* errno is set for us. */
1208 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1209 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1215 ctf_add_enum_encoded (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1216 const ctf_encoding_t
*ep
)
1220 /* First, create the enum if need be, using most of the same machinery as
1221 ctf_add_enum(), to ensure that we do not allow things past that are not
1222 enums or forwards to them. (This includes other slices: you cannot slice a
1223 slice, which would be a useless thing to do anyway.) */
1226 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1230 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1231 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1232 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1234 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1235 return CTF_ERR
; /* errno is set for us. */
1237 /* Now attach a suitable slice to it. */
1239 return ctf_add_slice (fp
, flag
, type
, ep
);
1243 ctf_add_forward (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1249 if (!ctf_forwardable_kind (kind
))
1250 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1252 /* If the type is already defined or exists as a forward tag, just
1253 return the ctf_id_t of the existing definition. */
1256 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1261 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1262 return CTF_ERR
; /* errno is set for us. */
1264 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1265 dtd
->dtd_data
.ctt_type
= kind
;
1271 ctf_add_typedef (ctf_file_t
*fp
, uint32_t flag
, const char *name
,
1276 ctf_file_t
*tmp
= fp
;
1278 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1279 return (ctf_set_errno (fp
, EINVAL
));
1281 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1282 return CTF_ERR
; /* errno is set for us. */
1284 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1286 return CTF_ERR
; /* errno is set for us. */
1288 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1289 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1295 ctf_add_volatile (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1297 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1301 ctf_add_const (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1303 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1307 ctf_add_restrict (ctf_file_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1309 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1313 ctf_add_enumerator (ctf_file_t
*fp
, ctf_id_t enid
, const char *name
,
1316 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1319 uint32_t kind
, vlen
, root
;
1323 return (ctf_set_errno (fp
, EINVAL
));
1325 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1326 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1329 return (ctf_set_errno (fp
, ECTF_BADID
));
1331 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1332 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1333 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1335 if (kind
!= CTF_K_ENUM
)
1336 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
1338 if (vlen
== CTF_MAX_VLEN
)
1339 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1341 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1342 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1344 if (strcmp (dmd
->dmd_name
, name
) == 0)
1345 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1348 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1349 return (ctf_set_errno (fp
, EAGAIN
));
1351 if ((s
= strdup (name
)) == NULL
)
1354 return (ctf_set_errno (fp
, EAGAIN
));
1358 dmd
->dmd_type
= CTF_ERR
;
1359 dmd
->dmd_offset
= 0;
1360 dmd
->dmd_value
= value
;
1362 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1363 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1365 fp
->ctf_flags
|= LCTF_DIRTY
;
1371 ctf_add_member_offset (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1372 ctf_id_t type
, unsigned long bit_offset
)
1374 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1377 ssize_t msize
, malign
, ssize
;
1378 uint32_t kind
, vlen
, root
;
1381 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1382 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1385 return (ctf_set_errno (fp
, ECTF_BADID
));
1387 if (name
!= NULL
&& name
[0] == '\0')
1390 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1391 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1392 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1394 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1395 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1397 if (vlen
== CTF_MAX_VLEN
)
1398 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1402 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1403 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1405 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1406 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1410 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1411 (malign
= ctf_type_align (fp
, type
)) < 0)
1413 /* The unimplemented type, and any type that resolves to it, has no size
1414 and no alignment: it can correspond to any number of compiler-inserted
1417 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1421 ctf_set_errno (fp
, 0);
1424 return -1; /* errno is set for us. */
1427 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1428 return (ctf_set_errno (fp
, EAGAIN
));
1430 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1433 return (ctf_set_errno (fp
, EAGAIN
));
1437 dmd
->dmd_type
= type
;
1438 dmd
->dmd_value
= -1;
1440 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1442 if (bit_offset
== (unsigned long) - 1)
1444 /* Natural alignment. */
1446 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1447 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1448 size_t off
= lmd
->dmd_offset
;
1450 ctf_encoding_t linfo
;
1453 /* Propagate any error from ctf_type_resolve. If the last member was
1454 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1455 cannot insert right after such a member without explicit offset
1456 specification, because its alignment and size is not known. */
1457 if (ltype
== CTF_ERR
)
1460 return -1; /* errno is set for us. */
1463 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1464 off
+= linfo
.cte_bits
;
1465 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1466 off
+= lsize
* CHAR_BIT
;
1468 /* Round up the offset of the end of the last member to
1469 the next byte boundary, convert 'off' to bytes, and
1470 then round it up again to the next multiple of the
1471 alignment required by the new member. Finally,
1472 convert back to bits and store the result in
1473 dmd_offset. Technically we could do more efficient
1474 packing if the new member is a bit-field, but we're
1475 the "compiler" and ANSI says we can do as we choose. */
1477 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1478 off
= roundup (off
, MAX (malign
, 1));
1479 dmd
->dmd_offset
= off
* CHAR_BIT
;
1480 ssize
= off
+ msize
;
1484 /* Specified offset in bits. */
1486 dmd
->dmd_offset
= bit_offset
;
1487 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1488 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1493 dmd
->dmd_offset
= 0;
1494 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1495 ssize
= MAX (ssize
, msize
);
1498 if ((size_t) ssize
> CTF_MAX_SIZE
)
1500 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1501 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1502 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1505 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1507 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1508 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1510 fp
->ctf_flags
|= LCTF_DIRTY
;
1515 ctf_add_member_encoded (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1516 ctf_id_t type
, unsigned long bit_offset
,
1517 const ctf_encoding_t encoding
)
1519 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1520 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1523 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1524 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1526 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1527 return -1; /* errno is set for us. */
1529 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1533 ctf_add_member (ctf_file_t
*fp
, ctf_id_t souid
, const char *name
,
1536 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1540 ctf_add_variable (ctf_file_t
*fp
, const char *name
, ctf_id_t ref
)
1543 ctf_file_t
*tmp
= fp
;
1545 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1546 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1548 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1549 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1551 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1552 return -1; /* errno is set for us. */
1554 /* Make sure this type is representable. */
1555 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1556 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1559 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1560 return (ctf_set_errno (fp
, EAGAIN
));
1562 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1565 return (ctf_set_errno (fp
, EAGAIN
));
1567 dvd
->dvd_type
= ref
;
1568 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1570 if (ctf_dvd_insert (fp
, dvd
) < 0)
1572 free (dvd
->dvd_name
);
1574 return -1; /* errno is set for us. */
1577 fp
->ctf_flags
|= LCTF_DIRTY
;
1582 enumcmp (const char *name
, int value
, void *arg
)
1584 ctf_bundle_t
*ctb
= arg
;
1587 if (ctf_enum_value (ctb
->ctb_file
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1589 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1590 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1593 if (value
!= bvalue
)
1595 ctf_dprintf ("Conflict due to value change: %i versus %i\n",
1603 enumadd (const char *name
, int value
, void *arg
)
1605 ctf_bundle_t
*ctb
= arg
;
1607 return (ctf_add_enumerator (ctb
->ctb_file
, ctb
->ctb_type
,
1612 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1615 ctf_bundle_t
*ctb
= arg
;
1618 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1623 if (ctf_member_info (ctb
->ctb_file
, ctb
->ctb_type
, name
, &ctm
) < 0)
1625 ctf_dprintf ("Conflict due to member %s iteration error: %s.\n", name
,
1626 ctf_errmsg (ctf_errno (ctb
->ctb_file
)));
1629 if (ctm
.ctm_offset
!= offset
)
1631 ctf_dprintf ("Conflict due to member %s offset change: "
1632 "%lx versus %lx\n", name
, ctm
.ctm_offset
, offset
);
1639 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1641 ctf_bundle_t
*ctb
= arg
;
1645 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1646 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1648 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1651 return (ctf_set_errno (ctb
->ctb_file
, EAGAIN
));
1654 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1655 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1657 dmd
->dmd_type
= type
;
1658 dmd
->dmd_offset
= offset
;
1659 dmd
->dmd_value
= -1;
1661 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1663 ctb
->ctb_file
->ctf_flags
|= LCTF_DIRTY
;
1667 /* The ctf_add_type routine is used to copy a type from a source CTF container
1668 to a dynamic destination container. This routine operates recursively by
1669 following the source type's links and embedded member types. If the
1670 destination container already contains a named type which has the same
1671 attributes, then we succeed and return this type but no changes occur. */
1673 ctf_add_type_internal (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
,
1674 ctf_file_t
*proc_tracking_fp
)
1676 ctf_id_t dst_type
= CTF_ERR
;
1677 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1678 ctf_file_t
*tmp_fp
= dst_fp
;
1682 uint32_t kind
, forward_kind
, flag
, vlen
;
1684 const ctf_type_t
*src_tp
, *dst_tp
;
1685 ctf_bundle_t src
, dst
;
1686 ctf_encoding_t src_en
, dst_en
;
1687 ctf_arinfo_t src_ar
, dst_ar
;
1691 ctf_id_t orig_src_type
= src_type
;
1693 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1694 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1696 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1697 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1699 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1700 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1701 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1703 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1704 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1705 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1706 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1708 /* If this is a type we are currently in the middle of adding, hand it
1709 straight back. (This lets us handle self-referential structures without
1710 considering forwards and empty structures the same as their completed
1713 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1717 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1718 (void *) (uintptr_t) src_type
))
1721 /* If this type has already been added from this container, and is the same
1722 kind and (if a struct or union) has the same number of members, hand it
1725 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1727 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1728 || kind
== CTF_K_ENUM
)
1730 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1731 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1739 forward_kind
= kind
;
1740 if (kind
== CTF_K_FORWARD
)
1741 forward_kind
= src_tp
->ctt_type
;
1743 /* If the source type has a name and is a root type (visible at the
1744 top-level scope), lookup the name in the destination container and
1745 verify that it is of the same kind before we do anything else. */
1747 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1748 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1751 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1754 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1755 unless dst_type is a forward declaration and src_type is a struct,
1756 union, or enum (i.e. the definition of the previous forward decl).
1758 We also allow addition in the opposite order (addition of a forward when a
1759 struct, union, or enum already exists), which is a NOP and returns the
1760 already-present struct, union, or enum. */
1762 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1764 if (kind
== CTF_K_FORWARD
1765 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1766 || dst_kind
== CTF_K_UNION
))
1768 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1772 if (dst_kind
!= CTF_K_FORWARD
1773 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1774 && kind
!= CTF_K_UNION
))
1776 ctf_dprintf ("Conflict for type %s: kinds differ, new: %i; "
1777 "old (ID %lx): %i\n", name
, kind
, dst_type
, dst_kind
);
1778 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1782 /* We take special action for an integer, float, or slice since it is
1783 described not only by its name but also its encoding. For integers,
1784 bit-fields exploit this degeneracy. */
1786 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1788 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1789 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1791 if (dst_type
!= CTF_ERR
)
1793 ctf_file_t
*fp
= dst_fp
;
1795 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1798 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1799 return CTF_ERR
; /* errno set for us. */
1801 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1803 /* The type that we found in the hash is also root-visible. If
1804 the two types match then use the existing one; otherwise,
1805 declare a conflict. Note: slices are not certain to match
1806 even if there is no conflict: we must check the contained type
1809 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1811 if (kind
!= CTF_K_SLICE
)
1813 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1819 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1824 /* We found a non-root-visible type in the hash. If its encoding
1825 is the same, we can reuse it, unless it is a slice. */
1827 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1829 if (kind
!= CTF_K_SLICE
)
1831 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1839 src
.ctb_file
= src_fp
;
1840 src
.ctb_type
= src_type
;
1843 dst
.ctb_file
= dst_fp
;
1844 dst
.ctb_type
= dst_type
;
1847 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1848 a new type with the same properties as src_type to dst_fp. If dst_type is
1849 not CTF_ERR, then we verify that dst_type has the same attributes as
1850 src_type. We recurse for embedded references. Before we start, we note
1851 that we are processing this type, to prevent infinite recursion: we do not
1852 re-process any type that appears in this list. The list is emptied
1853 wholesale at the end of processing everything in this recursive stack. */
1855 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1856 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1857 return ctf_set_errno (dst_fp
, ENOMEM
);
1862 /* If we found a match we will have either returned it or declared a
1864 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1868 /* If we found a match we will have either returned it or declared a
1870 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1874 /* We have checked for conflicting encodings: now try to add the
1876 src_type
= ctf_type_reference (src_fp
, src_type
);
1877 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1880 if (src_type
== CTF_ERR
)
1881 return CTF_ERR
; /* errno is set for us. */
1883 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1887 case CTF_K_VOLATILE
:
1889 case CTF_K_RESTRICT
:
1890 src_type
= ctf_type_reference (src_fp
, src_type
);
1891 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1894 if (src_type
== CTF_ERR
)
1895 return CTF_ERR
; /* errno is set for us. */
1897 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1901 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1902 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1904 src_ar
.ctr_contents
=
1905 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1907 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1910 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1912 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1913 return CTF_ERR
; /* errno is set for us. */
1915 if (dst_type
!= CTF_ERR
)
1917 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1918 return CTF_ERR
; /* errno is set for us. */
1920 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1922 ctf_dprintf ("Conflict for type %s against ID %lx: "
1923 "array info differs, old %lx/%lx/%x; "
1924 "new: %lx/%lx/%x\n", name
, dst_type
,
1925 src_ar
.ctr_contents
, src_ar
.ctr_index
,
1926 src_ar
.ctr_nelems
, dst_ar
.ctr_contents
,
1927 dst_ar
.ctr_index
, dst_ar
.ctr_nelems
);
1928 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1932 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1935 case CTF_K_FUNCTION
:
1936 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1942 if (ctc
.ctc_return
== CTF_ERR
)
1943 return CTF_ERR
; /* errno is set for us. */
1945 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1957 /* Technically to match a struct or union we need to check both
1958 ways (src members vs. dst, dst members vs. src) but we make
1959 this more optimal by only checking src vs. dst and comparing
1960 the total size of the structure (which we must do anyway)
1961 which covers the possibility of dst members not in src.
1962 This optimization can be defeated for unions, but is so
1963 pathological as to render it irrelevant for our purposes. */
1965 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1966 && dst_kind
!= CTF_K_FORWARD
)
1968 if (ctf_type_size (src_fp
, src_type
) !=
1969 ctf_type_size (dst_fp
, dst_type
))
1971 ctf_dprintf ("Conflict for type %s against ID %lx: "
1972 "union size differs, old %li, new %li\n",
1974 (long) ctf_type_size (src_fp
, src_type
),
1975 (long) ctf_type_size (dst_fp
, dst_type
));
1976 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1979 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1981 ctf_dprintf ("Conflict for type %s against ID %lx: "
1982 "members differ, see above\n", name
, dst_type
);
1983 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1989 /* Unlike the other cases, copying structs and unions is done
1990 manually so as to avoid repeated lookups in ctf_add_member
1991 and to ensure the exact same member offsets as in src_type. */
1993 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
1994 if (dst_type
== CTF_ERR
)
1995 return CTF_ERR
; /* errno is set for us. */
1997 dst
.ctb_type
= dst_type
;
2000 /* Pre-emptively add this struct to the type mapping so that
2001 structures that refer to themselves work. */
2002 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2004 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2005 errs
++; /* Increment errs and fail at bottom of case. */
2007 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2008 return CTF_ERR
; /* errno is set for us. */
2010 size
= (size_t) ssize
;
2011 if (size
> CTF_MAX_SIZE
)
2013 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2014 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2015 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2018 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2020 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2022 /* Make a final pass through the members changing each dmd_type (a
2023 src_fp type) to an equivalent type in dst_fp. We pass through all
2024 members, leaving any that fail set to CTF_ERR, unless they fail
2025 because they are marking a member of type not representable in this
2026 version of CTF, in which case we just want to silently omit them:
2027 no consumer can do anything with them anyway. */
2028 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2029 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2031 ctf_file_t
*dst
= dst_fp
;
2034 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2037 if ((dmd
->dmd_type
=
2038 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2039 proc_tracking_fp
)) == CTF_ERR
)
2041 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2046 dmd
->dmd_type
= memb_type
;
2050 return CTF_ERR
; /* errno is set for us. */
2055 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2056 && dst_kind
!= CTF_K_FORWARD
)
2058 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2059 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2061 ctf_dprintf ("Conflict for enum %s against ID %lx: "
2062 "members differ, see above\n", name
, dst_type
);
2063 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2068 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2069 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2070 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2071 return CTF_ERR
; /* errno is set for us */
2076 if (dst_type
== CTF_ERR
)
2077 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2081 src_type
= ctf_type_reference (src_fp
, src_type
);
2082 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2085 if (src_type
== CTF_ERR
)
2086 return CTF_ERR
; /* errno is set for us. */
2088 /* If dst_type is not CTF_ERR at this point, we should check if
2089 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2090 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2091 that vary based on things like if 32-bit then pid_t is int otherwise
2092 long. We therefore omit this check and assume that if the identically
2093 named typedef already exists in dst_fp, it is correct or
2096 if (dst_type
== CTF_ERR
)
2097 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2102 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2105 if (dst_type
!= CTF_ERR
)
2106 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2111 ctf_add_type (ctf_file_t
*dst_fp
, ctf_file_t
*src_fp
, ctf_id_t src_type
)
2115 if (!src_fp
->ctf_add_processing
)
2116 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2117 ctf_hash_eq_integer
,
2120 /* We store the hash on the source, because it contains only source type IDs:
2121 but callers will invariably expect errors to appear on the dest. */
2122 if (!src_fp
->ctf_add_processing
)
2123 return (ctf_set_errno (dst_fp
, ENOMEM
));
2125 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2126 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2131 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2133 ctf_gzwrite (ctf_file_t
*fp
, gzFile fd
)
2135 const unsigned char *buf
;
2139 resid
= sizeof (ctf_header_t
);
2140 buf
= (unsigned char *) fp
->ctf_header
;
2143 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2144 return (ctf_set_errno (fp
, errno
));
2149 resid
= fp
->ctf_size
;
2153 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2154 return (ctf_set_errno (fp
, errno
));
2162 /* Compress the specified CTF data stream and write it to the specified file
2165 ctf_compress_write (ctf_file_t
*fp
, int fd
)
2170 ctf_header_t
*hp
= &h
;
2171 ssize_t header_len
= sizeof (ctf_header_t
);
2172 ssize_t compress_len
;
2177 if (ctf_serialize (fp
) < 0)
2178 return -1; /* errno is set for us. */
2180 memcpy (hp
, fp
->ctf_header
, header_len
);
2181 hp
->cth_flags
|= CTF_F_COMPRESS
;
2182 compress_len
= compressBound (fp
->ctf_size
);
2184 if ((buf
= malloc (compress_len
)) == NULL
)
2185 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2187 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2188 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2190 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2191 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2195 while (header_len
> 0)
2197 if ((len
= write (fd
, hp
, header_len
)) < 0)
2199 err
= ctf_set_errno (fp
, errno
);
2207 while (compress_len
> 0)
2209 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2211 err
= ctf_set_errno (fp
, errno
);
2214 compress_len
-= len
;
2223 /* Optionally compress the specified CTF data stream and return it as a new
2224 dynamically-allocated string. */
2226 ctf_write_mem (ctf_file_t
*fp
, size_t *size
, size_t threshold
)
2231 ssize_t header_len
= sizeof (ctf_header_t
);
2232 ssize_t compress_len
;
2235 if (ctf_serialize (fp
) < 0)
2236 return NULL
; /* errno is set for us. */
2238 compress_len
= compressBound (fp
->ctf_size
);
2239 if (fp
->ctf_size
< threshold
)
2240 compress_len
= fp
->ctf_size
;
2241 if ((buf
= malloc (compress_len
2242 + sizeof (struct ctf_header
))) == NULL
)
2244 ctf_set_errno (fp
, ENOMEM
);
2248 hp
= (ctf_header_t
*) buf
;
2249 memcpy (hp
, fp
->ctf_header
, header_len
);
2250 bp
= buf
+ sizeof (struct ctf_header
);
2251 *size
= sizeof (struct ctf_header
);
2253 if (fp
->ctf_size
< threshold
)
2255 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2256 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2257 *size
+= fp
->ctf_size
;
2261 hp
->cth_flags
|= CTF_F_COMPRESS
;
2262 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2263 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2265 ctf_dprintf ("zlib deflate err: %s\n", zError (rc
));
2266 ctf_set_errno (fp
, ECTF_COMPRESS
);
2270 *size
+= compress_len
;
2275 /* Write the uncompressed CTF data stream to the specified file descriptor. */
2277 ctf_write (ctf_file_t
*fp
, int fd
)
2279 const unsigned char *buf
;
2283 if (ctf_serialize (fp
) < 0)
2284 return -1; /* errno is set for us. */
2286 resid
= sizeof (ctf_header_t
);
2287 buf
= (unsigned char *) fp
->ctf_header
;
2290 if ((len
= write (fd
, buf
, resid
)) <= 0)
2291 return (ctf_set_errno (fp
, errno
));
2296 resid
= fp
->ctf_size
;
2300 if ((len
= write (fd
, buf
, resid
)) <= 0)
2301 return (ctf_set_errno (fp
, errno
));