2 Copyright (C) 2019-2021 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>
26 #define EOVERFLOW ERANGE
30 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
33 /* Make sure the ptrtab has enough space for at least one more type.
35 We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
39 ctf_grow_ptrtab (ctf_dict_t
*fp
)
41 size_t new_ptrtab_len
= fp
->ctf_ptrtab_len
;
43 /* We allocate one more ptrtab entry than we need, for the initial zero,
44 plus one because the caller will probably allocate a new type. */
46 if (fp
->ctf_ptrtab
== NULL
)
47 new_ptrtab_len
= 1024;
48 else if ((fp
->ctf_typemax
+ 2) > fp
->ctf_ptrtab_len
)
49 new_ptrtab_len
= fp
->ctf_ptrtab_len
* 1.25;
51 if (new_ptrtab_len
!= fp
->ctf_ptrtab_len
)
55 if ((new_ptrtab
= realloc (fp
->ctf_ptrtab
,
56 new_ptrtab_len
* sizeof (uint32_t))) == NULL
)
57 return (ctf_set_errno (fp
, ENOMEM
));
59 fp
->ctf_ptrtab
= new_ptrtab
;
60 memset (fp
->ctf_ptrtab
+ fp
->ctf_ptrtab_len
, 0,
61 (new_ptrtab_len
- fp
->ctf_ptrtab_len
) * sizeof (uint32_t));
62 fp
->ctf_ptrtab_len
= new_ptrtab_len
;
67 /* To create an empty CTF dict, we just declare a zeroed header and call
68 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new dict r/w and
69 initialize the dynamic members. We start assigning type IDs at 1 because
70 type ID 0 is used as a sentinel and a not-found indicator. */
73 ctf_create (int *errp
)
75 static const ctf_header_t hdr
= { .cth_preamble
= { CTF_MAGIC
, CTF_VERSION
, 0 } };
77 ctf_dynhash_t
*dthash
;
78 ctf_dynhash_t
*dvhash
;
79 ctf_dynhash_t
*structs
= NULL
, *unions
= NULL
, *enums
= NULL
, *names
= NULL
;
80 ctf_dynhash_t
*objthash
= NULL
, *funchash
= NULL
;
85 dthash
= ctf_dynhash_create (ctf_hash_integer
, ctf_hash_eq_integer
,
89 ctf_set_open_errno (errp
, EAGAIN
);
93 dvhash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
97 ctf_set_open_errno (errp
, EAGAIN
);
101 structs
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
103 unions
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
105 enums
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
107 names
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
109 objthash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
111 funchash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
113 if (!structs
|| !unions
|| !enums
|| !names
)
115 ctf_set_open_errno (errp
, EAGAIN
);
119 cts
.cts_name
= _CTF_SECTION
;
121 cts
.cts_size
= sizeof (hdr
);
124 if ((fp
= ctf_bufopen_internal (&cts
, NULL
, NULL
, NULL
, 1, errp
)) == NULL
)
127 fp
->ctf_structs
.ctn_writable
= structs
;
128 fp
->ctf_unions
.ctn_writable
= unions
;
129 fp
->ctf_enums
.ctn_writable
= enums
;
130 fp
->ctf_names
.ctn_writable
= names
;
131 fp
->ctf_objthash
= objthash
;
132 fp
->ctf_funchash
= funchash
;
133 fp
->ctf_dthash
= dthash
;
134 fp
->ctf_dvhash
= dvhash
;
136 fp
->ctf_snapshots
= 1;
137 fp
->ctf_snapshot_lu
= 0;
138 fp
->ctf_flags
|= LCTF_DIRTY
;
140 ctf_set_ctl_hashes (fp
);
141 ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
142 if (ctf_grow_ptrtab (fp
) < 0)
144 ctf_set_open_errno (errp
, ctf_errno (fp
));
152 ctf_dynhash_destroy (structs
);
153 ctf_dynhash_destroy (unions
);
154 ctf_dynhash_destroy (enums
);
155 ctf_dynhash_destroy (names
);
156 ctf_dynhash_destroy (objthash
);
157 ctf_dynhash_destroy (funchash
);
158 ctf_dynhash_destroy (dvhash
);
160 ctf_dynhash_destroy (dthash
);
165 /* Compatibility: just update the threshold for ctf_discard. */
167 ctf_update (ctf_dict_t
*fp
)
169 if (!(fp
->ctf_flags
& LCTF_RDWR
))
170 return (ctf_set_errno (fp
, ECTF_RDONLY
));
172 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
177 ctf_name_table (ctf_dict_t
*fp
, int kind
)
182 return &fp
->ctf_structs
;
184 return &fp
->ctf_unions
;
186 return &fp
->ctf_enums
;
188 return &fp
->ctf_names
;
193 ctf_dtd_insert (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
196 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
,
199 ctf_set_errno (fp
, ENOMEM
);
203 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
204 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
206 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
207 (char *) name
, (void *) (uintptr_t)
210 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t)
212 ctf_set_errno (fp
, ENOMEM
);
216 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
221 ctf_dtd_delete (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
)
223 ctf_dmdef_t
*dmd
, *nmd
;
224 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
225 int name_kind
= kind
;
228 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
229 free (dtd
->dtd_vlen
);
236 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
237 dmd
!= NULL
; dmd
= nmd
)
239 if (dmd
->dmd_name
!= NULL
)
240 free (dmd
->dmd_name
);
241 nmd
= ctf_list_next (dmd
);
246 free (dtd
->dtd_u
.dtu_argv
);
249 name_kind
= dtd
->dtd_data
.ctt_type
;
253 if (dtd
->dtd_data
.ctt_name
254 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
255 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
257 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
259 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
262 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
267 ctf_dtd_lookup (const ctf_dict_t
*fp
, ctf_id_t type
)
269 return (ctf_dtdef_t
*)
270 ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) (uintptr_t) type
);
274 ctf_dynamic_type (const ctf_dict_t
*fp
, ctf_id_t id
)
278 if (!(fp
->ctf_flags
& LCTF_RDWR
))
281 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
284 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
286 if ((unsigned long) idx
<= fp
->ctf_typemax
)
287 return ctf_dtd_lookup (fp
, id
);
292 ctf_dvd_insert (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
294 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
296 ctf_set_errno (fp
, ENOMEM
);
299 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
304 ctf_dvd_delete (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
306 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
307 free (dvd
->dvd_name
);
309 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
314 ctf_dvd_lookup (const ctf_dict_t
*fp
, const char *name
)
316 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
319 /* Discard all of the dynamic type definitions and variable definitions that
320 have been added to the dict since the last call to ctf_update(). We locate
321 such types by scanning the dtd list and deleting elements that have type IDs
322 greater than ctf_dtoldid, which is set by ctf_update(), above, and by
323 scanning the variable list and deleting elements that have update IDs equal
324 to the current value of the last-update snapshot count (indicating that they
325 were added after the most recent call to ctf_update()). */
327 ctf_discard (ctf_dict_t
*fp
)
329 ctf_snapshot_id_t last_update
=
331 fp
->ctf_snapshot_lu
+ 1 };
333 /* Update required? */
334 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
337 return (ctf_rollback (fp
, last_update
));
341 ctf_snapshot (ctf_dict_t
*fp
)
343 ctf_snapshot_id_t snapid
;
344 snapid
.dtd_id
= fp
->ctf_typemax
;
345 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
349 /* Like ctf_discard(), only discards everything after a particular ID. */
351 ctf_rollback (ctf_dict_t
*fp
, ctf_snapshot_id_t id
)
353 ctf_dtdef_t
*dtd
, *ntd
;
354 ctf_dvdef_t
*dvd
, *nvd
;
356 if (!(fp
->ctf_flags
& LCTF_RDWR
))
357 return (ctf_set_errno (fp
, ECTF_RDONLY
));
359 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
360 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
362 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
367 ntd
= ctf_list_next (dtd
);
369 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
372 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
373 if (kind
== CTF_K_FORWARD
)
374 kind
= dtd
->dtd_data
.ctt_type
;
376 if (dtd
->dtd_data
.ctt_name
377 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
378 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
380 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
382 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
385 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
386 ctf_dtd_delete (fp
, dtd
);
389 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
391 nvd
= ctf_list_next (dvd
);
393 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
396 ctf_dvd_delete (fp
, dvd
);
399 fp
->ctf_typemax
= id
.dtd_id
;
400 fp
->ctf_snapshots
= id
.snapshot_id
;
402 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
403 fp
->ctf_flags
&= ~LCTF_DIRTY
;
409 ctf_add_generic (ctf_dict_t
*fp
, uint32_t flag
, const char *name
, int kind
,
410 size_t vlen
, ctf_dtdef_t
**rp
)
415 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
416 return (ctf_set_errno (fp
, EINVAL
));
418 if (!(fp
->ctf_flags
& LCTF_RDWR
))
419 return (ctf_set_errno (fp
, ECTF_RDONLY
));
421 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
422 return (ctf_set_errno (fp
, ECTF_FULL
));
424 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
425 return (ctf_set_errno (fp
, ECTF_FULL
));
427 /* Make sure ptrtab always grows to be big enough for all types. */
428 if (ctf_grow_ptrtab (fp
) < 0)
429 return CTF_ERR
; /* errno is set for us. */
431 if ((dtd
= calloc (1, sizeof (ctf_dtdef_t
))) == NULL
)
432 return (ctf_set_errno (fp
, EAGAIN
));
436 if ((dtd
->dtd_vlen
= calloc (1, vlen
)) == NULL
)
440 dtd
->dtd_vlen
= NULL
;
442 type
= ++fp
->ctf_typemax
;
443 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
445 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
446 dtd
->dtd_type
= type
;
448 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
451 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
452 goto err
; /* errno is set for us. */
454 fp
->ctf_flags
|= LCTF_DIRTY
;
460 ctf_set_errno (fp
, EAGAIN
);
462 free (dtd
->dtd_vlen
);
467 /* When encoding integer sizes, we want to convert a byte count in the range
468 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
469 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
485 ctf_add_encoded (ctf_dict_t
*fp
, uint32_t flag
,
486 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
493 return (ctf_set_errno (fp
, EINVAL
));
495 if (name
== NULL
|| name
[0] == '\0')
496 return (ctf_set_errno (fp
, ECTF_NONAME
));
498 if (!ctf_assert (fp
, kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
))
499 return -1; /* errno is set for us. */
501 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, sizeof (uint32_t),
503 return CTF_ERR
; /* errno is set for us. */
505 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
506 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
511 encoding
= CTF_INT_DATA (ep
->cte_format
, ep
->cte_offset
, ep
->cte_bits
);
514 encoding
= CTF_FP_DATA (ep
->cte_format
, ep
->cte_offset
, ep
->cte_bits
);
517 memcpy (dtd
->dtd_vlen
, &encoding
, sizeof (encoding
));
523 ctf_add_reftype (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
527 ctf_dict_t
*tmp
= fp
;
528 int child
= fp
->ctf_flags
& LCTF_CHILD
;
530 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
531 return (ctf_set_errno (fp
, EINVAL
));
533 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
534 return CTF_ERR
; /* errno is set for us. */
536 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, 0, &dtd
)) == CTF_ERR
)
537 return CTF_ERR
; /* errno is set for us. */
539 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
540 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
542 if (kind
!= CTF_K_POINTER
)
545 /* If we are adding a pointer, update the ptrtab, pointing at this type from
546 the type it points to. Note that ctf_typemax is at this point one higher
547 than we want to check against, because it's just been incremented for the
548 addition of this type. The pptrtab is lazily-updated as needed, so is not
551 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
552 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
554 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
555 && ref_idx
< fp
->ctf_typemax
)
556 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
562 ctf_add_slice (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
,
563 const ctf_encoding_t
*ep
)
567 ctf_id_t resolved_ref
= ref
;
570 const ctf_type_t
*tp
;
571 ctf_dict_t
*tmp
= fp
;
574 return (ctf_set_errno (fp
, EINVAL
));
576 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
577 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
579 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
580 return (ctf_set_errno (fp
, EINVAL
));
582 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
583 return CTF_ERR
; /* errno is set for us. */
585 /* Make sure we ultimately point to an integral type. We also allow slices to
586 point to the unimplemented type, for now, because the compiler can emit
587 such slices, though they're not very much use. */
589 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
590 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
592 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
595 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
597 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
,
598 sizeof (ctf_slice_t
), &dtd
)) == CTF_ERR
)
599 return CTF_ERR
; /* errno is set for us. */
601 memset (&slice
, 0, sizeof (ctf_slice_t
));
603 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
604 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
606 slice
.cts_type
= (uint32_t) ref
;
607 slice
.cts_bits
= ep
->cte_bits
;
608 slice
.cts_offset
= ep
->cte_offset
;
609 memcpy (dtd
->dtd_vlen
, &slice
, sizeof (ctf_slice_t
));
615 ctf_add_integer (ctf_dict_t
*fp
, uint32_t flag
,
616 const char *name
, const ctf_encoding_t
*ep
)
618 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
622 ctf_add_float (ctf_dict_t
*fp
, uint32_t flag
,
623 const char *name
, const ctf_encoding_t
*ep
)
625 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
629 ctf_add_pointer (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
631 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
635 ctf_add_array (ctf_dict_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
640 ctf_dict_t
*tmp
= fp
;
643 return (ctf_set_errno (fp
, EINVAL
));
645 if (arp
->ctr_contents
!= 0
646 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
647 return CTF_ERR
; /* errno is set for us. */
650 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
651 return CTF_ERR
; /* errno is set for us. */
653 if (ctf_type_kind (fp
, arp
->ctr_index
) == CTF_K_FORWARD
)
655 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
656 _("ctf_add_array: index type %lx is incomplete"),
658 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
661 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
,
662 sizeof (ctf_array_t
), &dtd
)) == CTF_ERR
)
663 return CTF_ERR
; /* errno is set for us. */
665 memset (&cta
, 0, sizeof (ctf_array_t
));
667 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
668 dtd
->dtd_data
.ctt_size
= 0;
669 cta
.cta_contents
= (uint32_t) arp
->ctr_contents
;
670 cta
.cta_index
= (uint32_t) arp
->ctr_index
;
671 cta
.cta_nelems
= arp
->ctr_nelems
;
672 memcpy (dtd
->dtd_vlen
, &cta
, sizeof (ctf_array_t
));
678 ctf_set_array (ctf_dict_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
680 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
683 if (!(fp
->ctf_flags
& LCTF_RDWR
))
684 return (ctf_set_errno (fp
, ECTF_RDONLY
));
687 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
688 return (ctf_set_errno (fp
, ECTF_BADID
));
690 vlen
= (ctf_array_t
*) dtd
->dtd_vlen
;
691 fp
->ctf_flags
|= LCTF_DIRTY
;
692 vlen
->cta_contents
= (uint32_t) arp
->ctr_contents
;
693 vlen
->cta_index
= (uint32_t) arp
->ctr_index
;
694 vlen
->cta_nelems
= arp
->ctr_nelems
;
700 ctf_add_function (ctf_dict_t
*fp
, uint32_t flag
,
701 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
706 uint32_t *vdat
= NULL
;
707 ctf_dict_t
*tmp
= fp
;
710 if (!(fp
->ctf_flags
& LCTF_RDWR
))
711 return (ctf_set_errno (fp
, ECTF_RDONLY
));
713 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
714 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
715 return (ctf_set_errno (fp
, EINVAL
));
717 vlen
= ctc
->ctc_argc
;
718 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
719 vlen
++; /* Add trailing zero to indicate varargs (see below). */
721 if (ctc
->ctc_return
!= 0
722 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
723 return CTF_ERR
; /* errno is set for us. */
725 if (vlen
> CTF_MAX_VLEN
)
726 return (ctf_set_errno (fp
, EOVERFLOW
));
728 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
729 return (ctf_set_errno (fp
, EAGAIN
));
731 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
734 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
737 return CTF_ERR
; /* errno is set for us. */
739 vdat
[i
] = (uint32_t) argv
[i
];
742 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
743 0, &dtd
)) == CTF_ERR
)
746 return CTF_ERR
; /* errno is set for us. */
749 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
750 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
752 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
753 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
754 dtd
->dtd_u
.dtu_argv
= vdat
;
760 ctf_add_struct_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
766 /* Promote root-visible forwards to structs. */
768 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
770 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
771 dtd
= ctf_dtd_lookup (fp
, type
);
772 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
773 0, &dtd
)) == CTF_ERR
)
774 return CTF_ERR
; /* errno is set for us. */
776 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
778 if (size
> CTF_MAX_SIZE
)
780 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
781 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
782 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
785 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
791 ctf_add_struct (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
793 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
797 ctf_add_union_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
803 /* Promote root-visible forwards to unions. */
805 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
807 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
808 dtd
= ctf_dtd_lookup (fp
, type
);
809 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
810 0, &dtd
)) == CTF_ERR
)
811 return CTF_ERR
; /* errno is set for us */
813 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
815 if (size
> CTF_MAX_SIZE
)
817 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
818 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
819 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
822 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
828 ctf_add_union (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
830 return (ctf_add_union_sized (fp
, flag
, name
, 0));
834 ctf_add_enum (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
839 /* Promote root-visible forwards to enums. */
841 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
843 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
844 dtd
= ctf_dtd_lookup (fp
, type
);
845 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
846 0, &dtd
)) == CTF_ERR
)
847 return CTF_ERR
; /* errno is set for us. */
849 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
850 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
856 ctf_add_enum_encoded (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
857 const ctf_encoding_t
*ep
)
861 /* First, create the enum if need be, using most of the same machinery as
862 ctf_add_enum(), to ensure that we do not allow things past that are not
863 enums or forwards to them. (This includes other slices: you cannot slice a
864 slice, which would be a useless thing to do anyway.) */
867 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
871 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
872 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
873 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
875 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
876 return CTF_ERR
; /* errno is set for us. */
878 /* Now attach a suitable slice to it. */
880 return ctf_add_slice (fp
, flag
, type
, ep
);
884 ctf_add_forward (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
890 if (!ctf_forwardable_kind (kind
))
891 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
893 if (name
== NULL
|| name
[0] == '\0')
894 return (ctf_set_errno (fp
, ECTF_NONAME
));
896 /* If the type is already defined or exists as a forward tag, just
897 return the ctf_id_t of the existing definition. */
899 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
904 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, 0, &dtd
)) == CTF_ERR
)
905 return CTF_ERR
; /* errno is set for us. */
907 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
908 dtd
->dtd_data
.ctt_type
= kind
;
914 ctf_add_typedef (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
919 ctf_dict_t
*tmp
= fp
;
921 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
922 return (ctf_set_errno (fp
, EINVAL
));
924 if (name
== NULL
|| name
[0] == '\0')
925 return (ctf_set_errno (fp
, ECTF_NONAME
));
927 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
928 return CTF_ERR
; /* errno is set for us. */
930 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
, 0,
932 return CTF_ERR
; /* errno is set for us. */
934 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
935 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
941 ctf_add_volatile (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
943 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
947 ctf_add_const (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
949 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
953 ctf_add_restrict (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
955 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
959 ctf_add_enumerator (ctf_dict_t
*fp
, ctf_id_t enid
, const char *name
,
962 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
965 uint32_t kind
, vlen
, root
;
969 return (ctf_set_errno (fp
, EINVAL
));
971 if (!(fp
->ctf_flags
& LCTF_RDWR
))
972 return (ctf_set_errno (fp
, ECTF_RDONLY
));
975 return (ctf_set_errno (fp
, ECTF_BADID
));
977 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
978 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
979 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
981 if (kind
!= CTF_K_ENUM
)
982 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
984 if (vlen
== CTF_MAX_VLEN
)
985 return (ctf_set_errno (fp
, ECTF_DTFULL
));
987 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
988 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
990 if (strcmp (dmd
->dmd_name
, name
) == 0)
991 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
994 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
995 return (ctf_set_errno (fp
, EAGAIN
));
997 if ((s
= strdup (name
)) == NULL
)
1000 return (ctf_set_errno (fp
, EAGAIN
));
1004 dmd
->dmd_type
= CTF_ERR
;
1005 dmd
->dmd_offset
= 0;
1006 dmd
->dmd_value
= value
;
1008 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1009 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1011 fp
->ctf_flags
|= LCTF_DIRTY
;
1017 ctf_add_member_offset (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
1018 ctf_id_t type
, unsigned long bit_offset
)
1020 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
1023 ssize_t msize
, malign
, ssize
;
1024 uint32_t kind
, vlen
, root
;
1026 int is_incomplete
= 0;
1028 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1029 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1032 return (ctf_set_errno (fp
, ECTF_BADID
));
1034 if (name
!= NULL
&& name
[0] == '\0')
1037 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1038 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1039 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1041 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
1042 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
1044 if (vlen
== CTF_MAX_VLEN
)
1045 return (ctf_set_errno (fp
, ECTF_DTFULL
));
1049 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1050 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1052 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
1053 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1057 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
1058 (malign
= ctf_type_align (fp
, type
)) < 0)
1060 /* The unimplemented type, and any type that resolves to it, has no size
1061 and no alignment: it can correspond to any number of compiler-inserted
1062 types. We allow incomplete types through since they are routinely
1063 added to the ends of structures, and can even be added elsewhere in
1064 structures by the deduplicator. They are assumed to be zero-size with
1065 no alignment: this is often wrong, but problems can be avoided in this
1066 case by explicitly specifying the size of the structure via the _sized
1067 functions. The deduplicator always does this. */
1071 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
1072 ctf_set_errno (fp
, 0);
1073 else if (ctf_errno (fp
) == ECTF_INCOMPLETE
)
1076 return -1; /* errno is set for us. */
1079 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1080 return (ctf_set_errno (fp
, EAGAIN
));
1082 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1085 return (ctf_set_errno (fp
, EAGAIN
));
1089 dmd
->dmd_type
= type
;
1090 dmd
->dmd_value
= -1;
1092 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
1094 if (bit_offset
== (unsigned long) - 1)
1096 /* Natural alignment. */
1098 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
1099 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
1100 size_t off
= lmd
->dmd_offset
;
1102 ctf_encoding_t linfo
;
1105 /* Propagate any error from ctf_type_resolve. If the last member was
1106 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
1107 cannot insert right after such a member without explicit offset
1108 specification, because its alignment and size is not known. */
1109 if (ltype
== CTF_ERR
)
1112 return -1; /* errno is set for us. */
1117 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
1118 _("ctf_add_member_offset: cannot add member %s of "
1119 "incomplete type %lx to struct %lx without "
1120 "specifying explicit offset\n"),
1121 name
? name
: _("(unnamed member)"), type
, souid
);
1122 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
1125 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
1126 off
+= linfo
.cte_bits
;
1127 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
1128 off
+= lsize
* CHAR_BIT
;
1129 else if (lsize
== -1 && ctf_errno (fp
) == ECTF_INCOMPLETE
)
1131 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
1132 _("ctf_add_member_offset: cannot add member %s of "
1133 "type %lx to struct %lx without specifying "
1134 "explicit offset after member %s of type %lx, "
1135 "which is an incomplete type\n"),
1136 name
? name
: _("(unnamed member)"), type
, souid
,
1137 lmd
->dmd_name
? lmd
->dmd_name
1138 : _("(unnamed member)"), ltype
);
1139 return -1; /* errno is set for us. */
1142 /* Round up the offset of the end of the last member to
1143 the next byte boundary, convert 'off' to bytes, and
1144 then round it up again to the next multiple of the
1145 alignment required by the new member. Finally,
1146 convert back to bits and store the result in
1147 dmd_offset. Technically we could do more efficient
1148 packing if the new member is a bit-field, but we're
1149 the "compiler" and ANSI says we can do as we choose. */
1151 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
1152 off
= roundup (off
, MAX (malign
, 1));
1153 dmd
->dmd_offset
= off
* CHAR_BIT
;
1154 ssize
= off
+ msize
;
1158 /* Specified offset in bits. */
1160 dmd
->dmd_offset
= bit_offset
;
1161 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1162 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
1167 dmd
->dmd_offset
= 0;
1168 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
1169 ssize
= MAX (ssize
, msize
);
1172 if ((size_t) ssize
> CTF_MAX_SIZE
)
1174 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1175 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
1176 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
1179 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
1181 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
1182 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
1184 fp
->ctf_flags
|= LCTF_DIRTY
;
1189 ctf_add_member_encoded (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
1190 ctf_id_t type
, unsigned long bit_offset
,
1191 const ctf_encoding_t encoding
)
1193 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1194 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1197 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
1198 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1200 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
1201 return -1; /* errno is set for us. */
1203 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
1207 ctf_add_member (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
1210 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
1214 ctf_add_variable (ctf_dict_t
*fp
, const char *name
, ctf_id_t ref
)
1217 ctf_dict_t
*tmp
= fp
;
1219 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1220 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1222 if (ctf_dvd_lookup (fp
, name
) != NULL
)
1223 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1225 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1226 return -1; /* errno is set for us. */
1228 /* Make sure this type is representable. */
1229 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
1230 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
1233 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
1234 return (ctf_set_errno (fp
, EAGAIN
));
1236 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
1239 return (ctf_set_errno (fp
, EAGAIN
));
1241 dvd
->dvd_type
= ref
;
1242 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
1244 if (ctf_dvd_insert (fp
, dvd
) < 0)
1246 free (dvd
->dvd_name
);
1248 return -1; /* errno is set for us. */
1251 fp
->ctf_flags
|= LCTF_DIRTY
;
1256 ctf_add_funcobjt_sym (ctf_dict_t
*fp
, int is_function
, const char *name
, ctf_id_t id
)
1258 ctf_dict_t
*tmp
= fp
;
1260 ctf_dynhash_t
*h
= is_function
? fp
->ctf_funchash
: fp
->ctf_objthash
;
1262 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1263 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1265 if (ctf_dynhash_lookup (fp
->ctf_objthash
, name
) != NULL
||
1266 ctf_dynhash_lookup (fp
->ctf_funchash
, name
) != NULL
)
1267 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
1269 if (ctf_lookup_by_id (&tmp
, id
) == NULL
)
1270 return -1; /* errno is set for us. */
1272 if (is_function
&& ctf_type_kind (fp
, id
) != CTF_K_FUNCTION
)
1273 return (ctf_set_errno (fp
, ECTF_NOTFUNC
));
1275 if ((dupname
= strdup (name
)) == NULL
)
1276 return (ctf_set_errno (fp
, ENOMEM
));
1278 if (ctf_dynhash_insert (h
, dupname
, (void *) (uintptr_t) id
) < 0)
1281 return (ctf_set_errno (fp
, ENOMEM
));
1287 ctf_add_objt_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
1289 return (ctf_add_funcobjt_sym (fp
, 0, name
, id
));
1293 ctf_add_func_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
1295 return (ctf_add_funcobjt_sym (fp
, 1, name
, id
));
1298 typedef struct ctf_bundle
1300 ctf_dict_t
*ctb_dict
; /* CTF dict handle. */
1301 ctf_id_t ctb_type
; /* CTF type identifier. */
1302 ctf_dtdef_t
*ctb_dtd
; /* CTF dynamic type definition (if any). */
1306 enumcmp (const char *name
, int value
, void *arg
)
1308 ctf_bundle_t
*ctb
= arg
;
1311 if (ctf_enum_value (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &bvalue
) < 0)
1313 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
1314 _("conflict due to enum %s iteration error"), name
);
1317 if (value
!= bvalue
)
1319 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
1320 _("conflict due to enum value change: %i versus %i"),
1328 enumadd (const char *name
, int value
, void *arg
)
1330 ctf_bundle_t
*ctb
= arg
;
1332 return (ctf_add_enumerator (ctb
->ctb_dict
, ctb
->ctb_type
,
1337 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
1340 ctf_bundle_t
*ctb
= arg
;
1343 /* Don't check nameless members (e.g. anonymous structs/unions) against each
1348 if (ctf_member_info (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &ctm
) < 0)
1350 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
1351 _("conflict due to struct member %s iteration error"),
1355 if (ctm
.ctm_offset
!= offset
)
1357 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
1358 _("conflict due to struct member %s offset change: "
1360 name
, ctm
.ctm_offset
, offset
);
1367 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
1369 ctf_bundle_t
*ctb
= arg
;
1373 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
1374 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
1376 /* Unnamed members in non-dynamic dicts have a name of "", while dynamic dicts
1382 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
1385 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
1388 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
1389 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
1391 dmd
->dmd_type
= type
;
1392 dmd
->dmd_offset
= offset
;
1393 dmd
->dmd_value
= -1;
1395 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
1397 ctb
->ctb_dict
->ctf_flags
|= LCTF_DIRTY
;
1401 /* Record the correspondence between a source and ctf_add_type()-added
1402 destination type: both types are translated into parent type IDs if need be,
1403 so they relate to the actual dictionary they are in. Outside controlled
1404 circumstances (like linking) it is probably not useful to do more than
1405 compare these pointers, since there is nothing stopping the user closing the
1406 source dict whenever they want to.
1408 Our OOM handling here is just to not do anything, because this is called deep
1409 enough in the call stack that doing anything useful is painfully difficult:
1410 the worst consequence if we do OOM is a bit of type duplication anyway. */
1413 ctf_add_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
,
1414 ctf_dict_t
*dst_fp
, ctf_id_t dst_type
)
1416 if (LCTF_TYPE_ISPARENT (src_fp
, src_type
) && src_fp
->ctf_parent
)
1417 src_fp
= src_fp
->ctf_parent
;
1419 src_type
= LCTF_TYPE_TO_INDEX(src_fp
, src_type
);
1421 if (LCTF_TYPE_ISPARENT (dst_fp
, dst_type
) && dst_fp
->ctf_parent
)
1422 dst_fp
= dst_fp
->ctf_parent
;
1424 dst_type
= LCTF_TYPE_TO_INDEX(dst_fp
, dst_type
);
1426 if (dst_fp
->ctf_link_type_mapping
== NULL
)
1428 ctf_hash_fun f
= ctf_hash_type_key
;
1429 ctf_hash_eq_fun e
= ctf_hash_eq_type_key
;
1431 if ((dst_fp
->ctf_link_type_mapping
= ctf_dynhash_create (f
, e
, free
,
1436 ctf_link_type_key_t
*key
;
1437 key
= calloc (1, sizeof (struct ctf_link_type_key
));
1441 key
->cltk_fp
= src_fp
;
1442 key
->cltk_idx
= src_type
;
1444 /* No OOM checking needed, because if this doesn't work the worst we'll do is
1445 add a few more duplicate types (which will probably run out of memory
1447 ctf_dynhash_insert (dst_fp
->ctf_link_type_mapping
, key
,
1448 (void *) (uintptr_t) dst_type
);
1451 /* Look up a type mapping: return 0 if none. The DST_FP is modified to point to
1452 the parent if need be. The ID returned is from the dst_fp's perspective. */
1454 ctf_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
, ctf_dict_t
**dst_fp
)
1456 ctf_link_type_key_t key
;
1457 ctf_dict_t
*target_fp
= *dst_fp
;
1458 ctf_id_t dst_type
= 0;
1460 if (LCTF_TYPE_ISPARENT (src_fp
, src_type
) && src_fp
->ctf_parent
)
1461 src_fp
= src_fp
->ctf_parent
;
1463 src_type
= LCTF_TYPE_TO_INDEX(src_fp
, src_type
);
1464 key
.cltk_fp
= src_fp
;
1465 key
.cltk_idx
= src_type
;
1467 if (target_fp
->ctf_link_type_mapping
)
1468 dst_type
= (uintptr_t) ctf_dynhash_lookup (target_fp
->ctf_link_type_mapping
,
1473 dst_type
= LCTF_INDEX_TO_TYPE (target_fp
, dst_type
,
1474 target_fp
->ctf_parent
!= NULL
);
1475 *dst_fp
= target_fp
;
1479 if (target_fp
->ctf_parent
)
1480 target_fp
= target_fp
->ctf_parent
;
1484 if (target_fp
->ctf_link_type_mapping
)
1485 dst_type
= (uintptr_t) ctf_dynhash_lookup (target_fp
->ctf_link_type_mapping
,
1489 dst_type
= LCTF_INDEX_TO_TYPE (target_fp
, dst_type
,
1490 target_fp
->ctf_parent
!= NULL
);
1492 *dst_fp
= target_fp
;
1496 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
1497 to a dynamic destination dictionary. This routine operates recursively by
1498 following the source type's links and embedded member types. If the
1499 destination dict already contains a named type which has the same attributes,
1500 then we succeed and return this type but no changes occur. */
1502 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
1503 ctf_dict_t
*proc_tracking_fp
)
1505 ctf_id_t dst_type
= CTF_ERR
;
1506 uint32_t dst_kind
= CTF_K_UNKNOWN
;
1507 ctf_dict_t
*tmp_fp
= dst_fp
;
1511 uint32_t kind
, forward_kind
, flag
, vlen
;
1513 const ctf_type_t
*src_tp
, *dst_tp
;
1514 ctf_bundle_t src
, dst
;
1515 ctf_encoding_t src_en
, dst_en
;
1516 ctf_arinfo_t src_ar
, dst_ar
;
1520 ctf_id_t orig_src_type
= src_type
;
1522 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
1523 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
1525 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
1526 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1528 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
1529 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
1530 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
1532 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
1533 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
1534 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
1535 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
1537 /* If this is a type we are currently in the middle of adding, hand it
1538 straight back. (This lets us handle self-referential structures without
1539 considering forwards and empty structures the same as their completed
1542 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
1546 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
1547 (void *) (uintptr_t) src_type
))
1550 /* If this type has already been added from this dictionary, and is the
1551 same kind and (if a struct or union) has the same number of members,
1552 hand it straight back. */
1554 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
1556 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
1557 || kind
== CTF_K_ENUM
)
1559 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
1560 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
1568 forward_kind
= kind
;
1569 if (kind
== CTF_K_FORWARD
)
1570 forward_kind
= src_tp
->ctt_type
;
1572 /* If the source type has a name and is a root type (visible at the top-level
1573 scope), lookup the name in the destination dictionary and verify that it is
1574 of the same kind before we do anything else. */
1576 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
1577 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
1580 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
1583 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
1584 unless dst_type is a forward declaration and src_type is a struct,
1585 union, or enum (i.e. the definition of the previous forward decl).
1587 We also allow addition in the opposite order (addition of a forward when a
1588 struct, union, or enum already exists), which is a NOP and returns the
1589 already-present struct, union, or enum. */
1591 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
1593 if (kind
== CTF_K_FORWARD
1594 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
1595 || dst_kind
== CTF_K_UNION
))
1597 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1601 if (dst_kind
!= CTF_K_FORWARD
1602 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
1603 && kind
!= CTF_K_UNION
))
1605 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
1606 _("ctf_add_type: conflict for type %s: "
1607 "kinds differ, new: %i; old (ID %lx): %i"),
1608 name
, kind
, dst_type
, dst_kind
);
1609 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1613 /* We take special action for an integer, float, or slice since it is
1614 described not only by its name but also its encoding. For integers,
1615 bit-fields exploit this degeneracy. */
1617 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
1619 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
1620 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1622 if (dst_type
!= CTF_ERR
)
1624 ctf_dict_t
*fp
= dst_fp
;
1626 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
1629 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
1630 return CTF_ERR
; /* errno set for us. */
1632 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
1634 /* The type that we found in the hash is also root-visible. If
1635 the two types match then use the existing one; otherwise,
1636 declare a conflict. Note: slices are not certain to match
1637 even if there is no conflict: we must check the contained type
1640 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1642 if (kind
!= CTF_K_SLICE
)
1644 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1650 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1655 /* We found a non-root-visible type in the hash. If its encoding
1656 is the same, we can reuse it, unless it is a slice. */
1658 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
1660 if (kind
!= CTF_K_SLICE
)
1662 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1670 src
.ctb_dict
= src_fp
;
1671 src
.ctb_type
= src_type
;
1674 dst
.ctb_dict
= dst_fp
;
1675 dst
.ctb_type
= dst_type
;
1678 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
1679 a new type with the same properties as src_type to dst_fp. If dst_type is
1680 not CTF_ERR, then we verify that dst_type has the same attributes as
1681 src_type. We recurse for embedded references. Before we start, we note
1682 that we are processing this type, to prevent infinite recursion: we do not
1683 re-process any type that appears in this list. The list is emptied
1684 wholesale at the end of processing everything in this recursive stack. */
1686 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
1687 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
1688 return ctf_set_errno (dst_fp
, ENOMEM
);
1693 /* If we found a match we will have either returned it or declared a
1695 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
1699 /* If we found a match we will have either returned it or declared a
1701 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
1705 /* We have checked for conflicting encodings: now try to add the
1707 src_type
= ctf_type_reference (src_fp
, src_type
);
1708 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1711 if (src_type
== CTF_ERR
)
1712 return CTF_ERR
; /* errno is set for us. */
1714 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
1718 case CTF_K_VOLATILE
:
1720 case CTF_K_RESTRICT
:
1721 src_type
= ctf_type_reference (src_fp
, src_type
);
1722 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1725 if (src_type
== CTF_ERR
)
1726 return CTF_ERR
; /* errno is set for us. */
1728 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
1732 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
1733 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
1735 src_ar
.ctr_contents
=
1736 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
1738 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
1741 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
1743 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
1744 return CTF_ERR
; /* errno is set for us. */
1746 if (dst_type
!= CTF_ERR
)
1748 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
1749 return CTF_ERR
; /* errno is set for us. */
1751 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
1753 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
1754 _("conflict for type %s against ID %lx: array info "
1755 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
1756 name
, dst_type
, src_ar
.ctr_contents
,
1757 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
1758 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
1760 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1764 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
1767 case CTF_K_FUNCTION
:
1768 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
1774 if (ctc
.ctc_return
== CTF_ERR
)
1775 return CTF_ERR
; /* errno is set for us. */
1777 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
1789 /* Technically to match a struct or union we need to check both
1790 ways (src members vs. dst, dst members vs. src) but we make
1791 this more optimal by only checking src vs. dst and comparing
1792 the total size of the structure (which we must do anyway)
1793 which covers the possibility of dst members not in src.
1794 This optimization can be defeated for unions, but is so
1795 pathological as to render it irrelevant for our purposes. */
1797 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1798 && dst_kind
!= CTF_K_FORWARD
)
1800 if (ctf_type_size (src_fp
, src_type
) !=
1801 ctf_type_size (dst_fp
, dst_type
))
1803 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
1804 _("conflict for type %s against ID %lx: union "
1805 "size differs, old %li, new %li"), name
,
1806 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
1807 (long) ctf_type_size (dst_fp
, dst_type
));
1808 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1811 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
1813 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
1814 _("conflict for type %s against ID %lx: members "
1815 "differ, see above"), name
, dst_type
);
1816 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1822 /* Unlike the other cases, copying structs and unions is done
1823 manually so as to avoid repeated lookups in ctf_add_member
1824 and to ensure the exact same member offsets as in src_type. */
1826 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, 0, &dtd
);
1827 if (dst_type
== CTF_ERR
)
1828 return CTF_ERR
; /* errno is set for us. */
1830 dst
.ctb_type
= dst_type
;
1833 /* Pre-emptively add this struct to the type mapping so that
1834 structures that refer to themselves work. */
1835 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
1837 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
1838 errs
++; /* Increment errs and fail at bottom of case. */
1840 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
1841 return CTF_ERR
; /* errno is set for us. */
1843 size
= (size_t) ssize
;
1844 if (size
> CTF_MAX_SIZE
)
1846 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1847 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1848 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1851 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1853 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
1855 /* Make a final pass through the members changing each dmd_type (a
1856 src_fp type) to an equivalent type in dst_fp. We pass through all
1857 members, leaving any that fail set to CTF_ERR, unless they fail
1858 because they are marking a member of type not representable in this
1859 version of CTF, in which case we just want to silently omit them:
1860 no consumer can do anything with them anyway. */
1861 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1862 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
1864 ctf_dict_t
*dst
= dst_fp
;
1867 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
1870 if ((dmd
->dmd_type
=
1871 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
1872 proc_tracking_fp
)) == CTF_ERR
)
1874 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
1879 dmd
->dmd_type
= memb_type
;
1883 return CTF_ERR
; /* errno is set for us. */
1888 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
1889 && dst_kind
!= CTF_K_FORWARD
)
1891 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
1892 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
1894 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
1895 _("conflict for enum %s against ID %lx: members "
1896 "differ, see above"), name
, dst_type
);
1897 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
1902 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
1903 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
1904 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
1905 return CTF_ERR
; /* errno is set for us */
1910 if (dst_type
== CTF_ERR
)
1911 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
1915 src_type
= ctf_type_reference (src_fp
, src_type
);
1916 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
1919 if (src_type
== CTF_ERR
)
1920 return CTF_ERR
; /* errno is set for us. */
1922 /* If dst_type is not CTF_ERR at this point, we should check if
1923 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
1924 ECTF_CONFLICT. However, this causes problems with bitness typedefs
1925 that vary based on things like if 32-bit then pid_t is int otherwise
1926 long. We therefore omit this check and assume that if the identically
1927 named typedef already exists in dst_fp, it is correct or
1930 if (dst_type
== CTF_ERR
)
1931 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
1936 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
1939 if (dst_type
!= CTF_ERR
)
1940 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
1945 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
1949 if (!src_fp
->ctf_add_processing
)
1950 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
1951 ctf_hash_eq_integer
,
1954 /* We store the hash on the source, because it contains only source type IDs:
1955 but callers will invariably expect errors to appear on the dest. */
1956 if (!src_fp
->ctf_add_processing
)
1957 return (ctf_set_errno (dst_fp
, ENOMEM
));
1959 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
1960 ctf_dynhash_empty (src_fp
->ctf_add_processing
);