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>
31 #define EOVERFLOW ERANGE
35 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
38 /* Make sure the ptrtab has enough space for at least one more type.
40 We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
44 ctf_grow_ptrtab (ctf_dict_t
*fp
)
46 size_t new_ptrtab_len
= fp
->ctf_ptrtab_len
;
48 /* We allocate one more ptrtab entry than we need, for the initial zero,
49 plus one because the caller will probably allocate a new type. */
51 if (fp
->ctf_ptrtab
== NULL
)
52 new_ptrtab_len
= 1024;
53 else if ((fp
->ctf_typemax
+ 2) > fp
->ctf_ptrtab_len
)
54 new_ptrtab_len
= fp
->ctf_ptrtab_len
* 1.25;
56 if (new_ptrtab_len
!= fp
->ctf_ptrtab_len
)
60 if ((new_ptrtab
= realloc (fp
->ctf_ptrtab
,
61 new_ptrtab_len
* sizeof (uint32_t))) == NULL
)
62 return (ctf_set_errno (fp
, ENOMEM
));
64 fp
->ctf_ptrtab
= new_ptrtab
;
65 memset (fp
->ctf_ptrtab
+ fp
->ctf_ptrtab_len
, 0,
66 (new_ptrtab_len
- fp
->ctf_ptrtab_len
) * sizeof (uint32_t));
67 fp
->ctf_ptrtab_len
= new_ptrtab_len
;
72 /* To create an empty CTF dict, we just declare a zeroed header and call
73 ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new dict r/w and
74 initialize the dynamic members. We start assigning type IDs at 1 because
75 type ID 0 is used as a sentinel and a not-found indicator. */
78 ctf_create (int *errp
)
80 static const ctf_header_t hdr
= { .cth_preamble
= { CTF_MAGIC
, CTF_VERSION
, 0 } };
82 ctf_dynhash_t
*dthash
;
83 ctf_dynhash_t
*dvhash
;
84 ctf_dynhash_t
*structs
= NULL
, *unions
= NULL
, *enums
= NULL
, *names
= NULL
;
85 ctf_dynhash_t
*objthash
= NULL
, *funchash
= NULL
;
90 dthash
= ctf_dynhash_create (ctf_hash_integer
, ctf_hash_eq_integer
,
94 ctf_set_open_errno (errp
, EAGAIN
);
98 dvhash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
102 ctf_set_open_errno (errp
, EAGAIN
);
106 structs
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
108 unions
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
110 enums
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
112 names
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
114 objthash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
116 funchash
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
118 if (!structs
|| !unions
|| !enums
|| !names
)
120 ctf_set_open_errno (errp
, EAGAIN
);
124 cts
.cts_name
= _CTF_SECTION
;
126 cts
.cts_size
= sizeof (hdr
);
129 if ((fp
= ctf_bufopen_internal (&cts
, NULL
, NULL
, NULL
, 1, errp
)) == NULL
)
132 fp
->ctf_structs
.ctn_writable
= structs
;
133 fp
->ctf_unions
.ctn_writable
= unions
;
134 fp
->ctf_enums
.ctn_writable
= enums
;
135 fp
->ctf_names
.ctn_writable
= names
;
136 fp
->ctf_objthash
= objthash
;
137 fp
->ctf_funchash
= funchash
;
138 fp
->ctf_dthash
= dthash
;
139 fp
->ctf_dvhash
= dvhash
;
141 fp
->ctf_snapshots
= 1;
142 fp
->ctf_snapshot_lu
= 0;
143 fp
->ctf_flags
|= LCTF_DIRTY
;
145 ctf_set_ctl_hashes (fp
);
146 ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
147 if (ctf_grow_ptrtab (fp
) < 0)
149 ctf_set_open_errno (errp
, ctf_errno (fp
));
157 ctf_dynhash_destroy (structs
);
158 ctf_dynhash_destroy (unions
);
159 ctf_dynhash_destroy (enums
);
160 ctf_dynhash_destroy (names
);
161 ctf_dynhash_destroy (objthash
);
162 ctf_dynhash_destroy (funchash
);
163 ctf_dynhash_destroy (dvhash
);
165 ctf_dynhash_destroy (dthash
);
170 /* Delete data symbols that have been assigned names from the variable section.
171 Must be called from within ctf_serialize, because that is the only place
172 you can safely delete variables without messing up ctf_rollback. */
175 symtypetab_delete_nonstatic_vars (ctf_dict_t
*fp
, ctf_dict_t
*symfp
)
177 ctf_dvdef_t
*dvd
, *nvd
;
180 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
182 nvd
= ctf_list_next (dvd
);
184 if (((type
= (ctf_id_t
) (uintptr_t)
185 ctf_dynhash_lookup (fp
->ctf_objthash
, dvd
->dvd_name
)) > 0)
186 && ctf_dynhash_lookup (symfp
->ctf_dynsyms
, dvd
->dvd_name
) != NULL
187 && type
== dvd
->dvd_type
)
188 ctf_dvd_delete (fp
, dvd
);
194 /* Determine if a symbol is "skippable" and should never appear in the
195 symtypetab sections. */
198 ctf_symtab_skippable (ctf_link_sym_t
*sym
)
200 /* Never skip symbols whose name is not yet known. */
201 if (sym
->st_nameidx_set
)
204 return (sym
->st_name
== NULL
|| sym
->st_name
[0] == 0
205 || sym
->st_shndx
== SHN_UNDEF
206 || strcmp (sym
->st_name
, "_START_") == 0
207 || strcmp (sym
->st_name
, "_END_") == 0
208 || (sym
->st_type
== STT_OBJECT
&& sym
->st_shndx
== SHN_EXTABS
209 && sym
->st_value
== 0));
212 /* Symtypetab emission flags. */
214 #define CTF_SYMTYPETAB_EMIT_FUNCTION 0x1
215 #define CTF_SYMTYPETAB_EMIT_PAD 0x2
216 #define CTF_SYMTYPETAB_FORCE_INDEXED 0x4
218 /* Get the number of symbols in a symbol hash, the count of symbols, the maximum
219 seen, the eventual size, without any padding elements, of the func/data and
220 (if generated) index sections, and the size of accumulated padding elements.
221 The linker-reported set of symbols is found in SYMFP: it may be NULL if
222 symbol filtering is not desired, in which case CTF_SYMTYPETAB_FORCE_INDEXED
223 will always be set in the flags.
225 Also figure out if any symbols need to be moved to the variable section, and
226 add them (if not already present). */
228 _libctf_nonnull_ ((1,3,4,5,6,7,8))
230 symtypetab_density (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, ctf_dynhash_t
*symhash
,
231 size_t *count
, size_t *max
, size_t *unpadsize
,
232 size_t *padsize
, size_t *idxsize
, int flags
)
234 ctf_next_t
*i
= NULL
;
237 ctf_dynhash_t
*linker_known
= NULL
;
247 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
249 /* Make a dynhash citing only symbols reported by the linker of the
250 appropriate type, then traverse all potential-symbols we know the types
251 of, removing them from linker_known as we go. Once this is done, the
252 only symbols remaining in linker_known are symbols we don't know the
253 types of: we must emit pads for those symbols that are below the
254 maximum symbol we will emit (any beyond that are simply skipped).
256 If there are none, this symtypetab will be empty: just report that. */
258 if (!symfp
->ctf_dynsyms
)
261 if ((linker_known
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
262 NULL
, NULL
)) == NULL
)
263 return (ctf_set_errno (fp
, ENOMEM
));
265 while ((err
= ctf_dynhash_cnext (symfp
->ctf_dynsyms
, &i
,
266 &name
, &ctf_sym
)) == 0)
268 ctf_link_sym_t
*sym
= (ctf_link_sym_t
*) ctf_sym
;
270 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
271 && sym
->st_type
!= STT_FUNC
)
272 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
273 && sym
->st_type
!= STT_OBJECT
))
276 if (ctf_symtab_skippable (sym
))
279 /* This should only be true briefly before all the names are
280 finalized, long before we get this far. */
281 if (!ctf_assert (fp
, !sym
->st_nameidx_set
))
282 return -1; /* errno is set for us. */
284 if (ctf_dynhash_cinsert (linker_known
, name
, ctf_sym
) < 0)
286 ctf_dynhash_destroy (linker_known
);
287 return (ctf_set_errno (fp
, ENOMEM
));
290 if (err
!= ECTF_NEXT_END
)
292 ctf_err_warn (fp
, 0, err
, _("iterating over linker-known symbols during "
294 ctf_dynhash_destroy (linker_known
);
295 return (ctf_set_errno (fp
, err
));
299 while ((err
= ctf_dynhash_cnext (symhash
, &i
, &name
, NULL
)) == 0)
303 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
305 /* Linker did not report symbol in symtab. Remove it from the
306 set of known data symbols and continue. */
307 if ((sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, name
)) == NULL
)
309 ctf_dynhash_remove (symhash
, name
);
313 /* We don't remove skippable symbols from the symhash because we don't
314 want them to be migrated into variables. */
315 if (ctf_symtab_skippable (sym
))
318 if ((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
319 && sym
->st_type
!= STT_FUNC
)
321 ctf_err_warn (fp
, 1, 0, _("Symbol %x added to CTF as a function "
322 "but is of type %x\n"),
323 sym
->st_symidx
, sym
->st_type
);
324 ctf_dynhash_remove (symhash
, name
);
327 else if (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
328 && sym
->st_type
!= STT_OBJECT
)
330 ctf_err_warn (fp
, 1, 0, _("Symbol %x added to CTF as a data "
331 "object but is of type %x\n"),
332 sym
->st_symidx
, sym
->st_type
);
333 ctf_dynhash_remove (symhash
, name
);
337 ctf_dynhash_remove (linker_known
, name
);
339 *unpadsize
+= sizeof (uint32_t);
342 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
344 if (*max
< sym
->st_symidx
)
345 *max
= sym
->st_symidx
;
350 if (err
!= ECTF_NEXT_END
)
352 ctf_err_warn (fp
, 0, err
, _("iterating over CTF symtypetab during "
354 ctf_dynhash_destroy (linker_known
);
355 return (ctf_set_errno (fp
, err
));
358 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
360 while ((err
= ctf_dynhash_cnext (linker_known
, &i
, NULL
, &ctf_sym
)) == 0)
362 ctf_link_sym_t
*sym
= (ctf_link_sym_t
*) ctf_sym
;
364 if (sym
->st_symidx
> *max
)
367 if (err
!= ECTF_NEXT_END
)
369 ctf_err_warn (fp
, 0, err
, _("iterating over linker-known symbols "
370 "during CTF serialization"));
371 ctf_dynhash_destroy (linker_known
);
372 return (ctf_set_errno (fp
, err
));
376 *idxsize
= *count
* sizeof (uint32_t);
377 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
378 *padsize
= (ctf_dynhash_elements (linker_known
) - beyond_max
) * sizeof (uint32_t);
380 ctf_dynhash_destroy (linker_known
);
384 /* Emit an objt or func symtypetab into DP in a particular order defined by an
385 array of ctf_link_sym_t or symbol names passed in. The index has NIDX
386 elements in it: unindexed output would terminate at symbol OUTMAX and is in
387 any case no larger than SIZE bytes. Some index elements are expected to be
388 skipped: see symtypetab_density. The linker-reported set of symbols (if any)
389 is found in SYMFP. */
391 emit_symtypetab (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, uint32_t *dp
,
392 ctf_link_sym_t
**idx
, const char **nameidx
, uint32_t nidx
,
393 uint32_t outmax
, int size
, int flags
)
397 ctf_dynhash_t
*symhash
;
399 ctf_dprintf ("Emitting table of size %i, outmax %u, %u symtypetab entries, "
400 "flags %i\n", size
, outmax
, nidx
, flags
);
402 /* Empty table? Nothing to do. */
406 if (flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
407 symhash
= fp
->ctf_funchash
;
409 symhash
= fp
->ctf_objthash
;
411 for (i
= 0; i
< nidx
; i
++)
413 const char *sym_name
;
416 /* If we have a linker-reported set of symbols, we may be given that set
417 to work from, or a set of symbol names. In both cases we want to look
418 at the corresponding linker-reported symbol (if any). */
419 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
421 ctf_link_sym_t
*this_link_sym
;
424 this_link_sym
= idx
[i
];
426 this_link_sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, nameidx
[i
]);
428 /* Unreported symbol number. No pad, no nothing. */
432 /* Symbol of the wrong type, or skippable? This symbol is not in this
434 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
435 && this_link_sym
->st_type
!= STT_FUNC
)
436 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
437 && this_link_sym
->st_type
!= STT_OBJECT
))
440 if (ctf_symtab_skippable (this_link_sym
))
443 sym_name
= this_link_sym
->st_name
;
445 /* Linker reports symbol of a different type to the symbol we actually
446 added? Skip the symbol. No pad, since the symbol doesn't actually
447 belong in this table at all. (Warned about in
448 symtypetab_density.) */
449 if ((this_link_sym
->st_type
== STT_FUNC
)
450 && (ctf_dynhash_lookup (fp
->ctf_objthash
, sym_name
)))
453 if ((this_link_sym
->st_type
== STT_OBJECT
)
454 && (ctf_dynhash_lookup (fp
->ctf_funchash
, sym_name
)))
458 sym_name
= nameidx
[i
];
460 /* Symbol in index but no type set? Silently skip and (optionally)
461 pad. (In force-indexed mode, this is also where we track symbols of
462 the wrong type for this round of insertion.) */
463 if ((type
= ctf_dynhash_lookup (symhash
, sym_name
)) == NULL
)
465 if (flags
& CTF_SYMTYPETAB_EMIT_PAD
)
470 if (!ctf_assert (fp
, (((char *) dpp
) - (char *) dp
) < size
))
471 return -1; /* errno is set for us. */
473 *dpp
++ = (ctf_id_t
) (uintptr_t) type
;
475 /* When emitting unindexed output, all later symbols are pads: stop
477 if ((flags
& CTF_SYMTYPETAB_EMIT_PAD
) && idx
[i
]->st_symidx
== outmax
)
484 /* Emit an objt or func symtypetab index into DP in a paticular order defined by
485 an array of symbol names passed in. Stop at NIDX. The linker-reported set
486 of symbols (if any) is found in SYMFP. */
488 emit_symtypetab_index (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, uint32_t *dp
,
489 const char **idx
, uint32_t nidx
, int size
, int flags
)
493 ctf_dynhash_t
*symhash
;
495 ctf_dprintf ("Emitting index of size %i, %u entries reported by linker, "
496 "flags %i\n", size
, nidx
, flags
);
498 /* Empty table? Nothing to do. */
502 if (flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
503 symhash
= fp
->ctf_funchash
;
505 symhash
= fp
->ctf_objthash
;
507 /* Indexes should always be unpadded. */
508 if (!ctf_assert (fp
, !(flags
& CTF_SYMTYPETAB_EMIT_PAD
)))
509 return -1; /* errno is set for us. */
511 for (i
= 0; i
< nidx
; i
++)
513 const char *sym_name
;
516 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
518 ctf_link_sym_t
*this_link_sym
;
520 this_link_sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, idx
[i
]);
522 /* This is an index: unreported symbols should never appear in it. */
523 if (!ctf_assert (fp
, this_link_sym
!= NULL
))
524 return -1; /* errno is set for us. */
526 /* Symbol of the wrong type, or skippable? This symbol is not in this
528 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
529 && this_link_sym
->st_type
!= STT_FUNC
)
530 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
531 && this_link_sym
->st_type
!= STT_OBJECT
))
534 if (ctf_symtab_skippable (this_link_sym
))
537 sym_name
= this_link_sym
->st_name
;
539 /* Linker reports symbol of a different type to the symbol we actually
540 added? Skip the symbol. */
541 if ((this_link_sym
->st_type
== STT_FUNC
)
542 && (ctf_dynhash_lookup (fp
->ctf_objthash
, sym_name
)))
545 if ((this_link_sym
->st_type
== STT_OBJECT
)
546 && (ctf_dynhash_lookup (fp
->ctf_funchash
, sym_name
)))
552 /* Symbol in index and reported by linker, but no type set? Silently skip
553 and (optionally) pad. (In force-indexed mode, this is also where we
554 track symbols of the wrong type for this round of insertion.) */
555 if ((type
= ctf_dynhash_lookup (symhash
, sym_name
)) == NULL
)
558 ctf_str_add_ref (fp
, sym_name
, dpp
++);
560 if (!ctf_assert (fp
, (((char *) dpp
) - (char *) dp
) <= size
))
561 return -1; /* errno is set for us. */
567 static unsigned char *
568 ctf_copy_smembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
570 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
573 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
575 ctf_member_t
*copied
;
578 ctm
.ctm_type
= (uint32_t) dmd
->dmd_type
;
579 ctm
.ctm_offset
= (uint32_t) dmd
->dmd_offset
;
581 memcpy (t
, &ctm
, sizeof (ctm
));
582 copied
= (ctf_member_t
*) t
;
584 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctm_name
);
592 static unsigned char *
593 ctf_copy_lmembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
595 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
598 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
600 ctf_lmember_t
*copied
;
603 ctlm
.ctlm_type
= (uint32_t) dmd
->dmd_type
;
604 ctlm
.ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (dmd
->dmd_offset
);
605 ctlm
.ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (dmd
->dmd_offset
);
607 memcpy (t
, &ctlm
, sizeof (ctlm
));
608 copied
= (ctf_lmember_t
*) t
;
610 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctlm_name
);
618 static unsigned char *
619 ctf_copy_emembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
621 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
624 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
628 cte
.cte_value
= dmd
->dmd_value
;
629 memcpy (t
, &cte
, sizeof (cte
));
630 copied
= (ctf_enum_t
*) t
;
631 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->cte_name
);
638 /* Sort a newly-constructed static variable array. */
640 typedef struct ctf_sort_var_arg_cb
644 } ctf_sort_var_arg_cb_t
;
647 ctf_sort_var (const void *one_
, const void *two_
, void *arg_
)
649 const ctf_varent_t
*one
= one_
;
650 const ctf_varent_t
*two
= two_
;
651 ctf_sort_var_arg_cb_t
*arg
= arg_
;
653 return (strcmp (ctf_strraw_explicit (arg
->fp
, one
->ctv_name
, arg
->strtab
),
654 ctf_strraw_explicit (arg
->fp
, two
->ctv_name
, arg
->strtab
)));
657 /* Compatibility: just update the threshold for ctf_discard. */
659 ctf_update (ctf_dict_t
*fp
)
661 if (!(fp
->ctf_flags
& LCTF_RDWR
))
662 return (ctf_set_errno (fp
, ECTF_RDONLY
));
664 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
668 /* If the specified CTF dict is writable and has been modified, reload this dict
669 with the updated type definitions, ready for serialization. In order to make
670 this code and the rest of libctf as simple as possible, we perform updates by
671 taking the dynamic type definitions and creating an in-memory CTF dict
672 containing the definitions, and then call ctf_simple_open_internal() on it.
673 We perform one extra trick here for the benefit of callers and to keep our
674 code simple: ctf_simple_open_internal() will return a new ctf_dict_t, but we
675 want to keep the fp constant for the caller, so after
676 ctf_simple_open_internal() returns, we use memcpy to swap the interior of the
677 old and new ctf_dict_t's, and then free the old. */
679 ctf_serialize (ctf_dict_t
*fp
)
681 ctf_dict_t ofp
, *nfp
;
682 ctf_header_t hdr
, *hdrp
;
685 ctf_varent_t
*dvarents
;
686 ctf_strs_writable_t strtab
;
690 size_t buf_size
, type_size
, objt_size
, func_size
;
691 size_t objt_unpadsize
, func_unpadsize
, objt_padsize
, func_padsize
;
692 size_t funcidx_size
, objtidx_size
;
693 size_t nvars
, nfuncs
, nobjts
, maxobjt
, maxfunc
;
694 size_t nsymtypes
= 0;
695 const char **sym_name_order
= NULL
;
696 unsigned char *buf
= NULL
, *newbuf
;
699 /* Symtab filtering. If filter_syms is true, symfp is set: otherwise,
700 CTF_SYMTYPETAB_FORCE_INDEXED is set in symflags. */
704 ctf_dict_t
*symfp
= NULL
;
706 if (!(fp
->ctf_flags
& LCTF_RDWR
))
707 return (ctf_set_errno (fp
, ECTF_RDONLY
));
709 /* Update required? */
710 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
713 /* If doing a writeout as part of linking, and the link flags request it,
714 filter out reported symbols from the variable section, and filter out all
715 other symbols from the symtypetab sections. (If we are not linking, the
716 symbols are sorted; if we are linking, don't bother sorting if we are not
717 filtering out reported symbols: this is almost certaily an ld -r and only
718 the linker is likely to consume these symtypetabs again. The linker
719 doesn't care what order the symtypetab entries is in, since it only
720 iterates over symbols and does not use the ctf_lookup_by_symbol* API.) */
722 if (fp
->ctf_flags
& LCTF_LINKING
)
724 filter_syms
= !(fp
->ctf_link_flags
& CTF_LINK_NO_FILTER_REPORTED_SYMS
);
729 /* Fill in an initial CTF header. We will leave the label, object,
730 and function sections empty and only output a header, type section,
731 and string table. The type section begins at a 4-byte aligned
732 boundary past the CTF header itself (at relative offset zero). The flag
733 indicating a new-style function info section (an array of CTF_K_FUNCTION
734 type IDs in the types section) is flipped on. */
736 memset (&hdr
, 0, sizeof (hdr
));
737 hdr
.cth_magic
= CTF_MAGIC
;
738 hdr
.cth_version
= CTF_VERSION
;
740 /* This is a new-format func info section, and the symtab and strtab come out
741 of the dynsym and dynstr these days. */
742 hdr
.cth_flags
= (CTF_F_NEWFUNCINFO
| CTF_F_DYNSTR
);
744 /* Iterate through the dynamic type definition list and compute the
745 size of the CTF type section we will need to generate. */
747 for (type_size
= 0, dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
748 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
750 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
751 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
753 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
754 type_size
+= sizeof (ctf_stype_t
);
756 type_size
+= sizeof (ctf_type_t
);
762 type_size
+= sizeof (uint32_t);
765 type_size
+= sizeof (ctf_array_t
);
768 type_size
+= sizeof (ctf_slice_t
);
771 type_size
+= sizeof (uint32_t) * (vlen
+ (vlen
& 1));
775 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
776 type_size
+= sizeof (ctf_member_t
) * vlen
;
778 type_size
+= sizeof (ctf_lmember_t
) * vlen
;
781 type_size
+= sizeof (ctf_enum_t
) * vlen
;
786 /* Find the dict to which the linker has reported symbols, if any. */
790 if (!fp
->ctf_dynsyms
&& fp
->ctf_parent
&& fp
->ctf_parent
->ctf_dynsyms
)
791 symfp
= fp
->ctf_parent
;
796 /* If not filtering, keep all potential symbols in an unsorted, indexed
799 symflags
= CTF_SYMTYPETAB_FORCE_INDEXED
;
801 hdr
.cth_flags
|= CTF_F_IDXSORTED
;
803 if (!ctf_assert (fp
, (filter_syms
&& symfp
)
804 || (!filter_syms
&& !symfp
805 && ((symflags
& CTF_SYMTYPETAB_FORCE_INDEXED
) != 0))))
808 /* Work out the sizes of the object and function sections, and work out the
809 number of pad (unassigned) symbols in each, and the overall size of the
812 if (symtypetab_density (fp
, symfp
, fp
->ctf_objthash
, &nobjts
, &maxobjt
,
813 &objt_unpadsize
, &objt_padsize
, &objtidx_size
,
815 return -1; /* errno is set for us. */
817 ctf_dprintf ("Object symtypetab: %i objects, max %i, unpadded size %i, "
818 "%i bytes of pads, index size %i\n", (int) nobjts
, (int) maxobjt
,
819 (int) objt_unpadsize
, (int) objt_padsize
, (int) objtidx_size
);
821 if (symtypetab_density (fp
, symfp
, fp
->ctf_funchash
, &nfuncs
, &maxfunc
,
822 &func_unpadsize
, &func_padsize
, &funcidx_size
,
823 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
824 return -1; /* errno is set for us. */
826 ctf_dprintf ("Function symtypetab: %i functions, max %i, unpadded size %i, "
827 "%i bytes of pads, index size %i\n", (int) nfuncs
, (int) maxfunc
,
828 (int) func_unpadsize
, (int) func_padsize
, (int) funcidx_size
);
830 /* If we are filtering symbols out, those symbols that the linker has not
831 reported have now been removed from the ctf_objthash and ctf_funchash.
832 Delete entries from the variable section that duplicate newly-added data
833 symbols. There's no need to migrate new ones in, because the compiler
834 always emits both a variable and a data symbol simultaneously, and
835 filtering only happens at final link time. */
837 if (filter_syms
&& symfp
->ctf_dynsyms
&&
838 symtypetab_delete_nonstatic_vars (fp
, symfp
) < 0)
841 /* It is worth indexing each section if it would save space to do so, due to
842 reducing the number of pads sufficiently. A pad is the same size as a
843 single index entry: but index sections compress relatively poorly compared
844 to constant pads, so it takes a lot of contiguous padding to equal one
845 index section entry. It would be nice to be able to *verify* whether we
846 would save space after compression rather than guessing, but this seems
847 difficult, since it would require complete reserialization. Regardless, if
848 the linker has not reported any symbols (e.g. if this is not a final link
849 but just an ld -r), we must emit things in indexed fashion just as the
852 objt_size
= objt_unpadsize
;
853 if (!(symflags
& CTF_SYMTYPETAB_FORCE_INDEXED
)
854 && ((objt_padsize
+ objt_unpadsize
) * CTF_INDEX_PAD_THRESHOLD
857 objt_size
+= objt_padsize
;
861 func_size
= func_unpadsize
;
862 if (!(symflags
& CTF_SYMTYPETAB_FORCE_INDEXED
)
863 && ((func_padsize
+ func_unpadsize
) * CTF_INDEX_PAD_THRESHOLD
866 func_size
+= func_padsize
;
870 /* Computing the number of entries in the CTF variable section is much
873 for (nvars
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
);
874 dvd
!= NULL
; dvd
= ctf_list_next (dvd
), nvars
++);
876 /* Compute the size of the CTF buffer we need, sans only the string table,
877 then allocate a new buffer and memcpy the finished header to the start of
878 the buffer. (We will adjust this later with strtab length info.) */
880 hdr
.cth_lbloff
= hdr
.cth_objtoff
= 0;
881 hdr
.cth_funcoff
= hdr
.cth_objtoff
+ objt_size
;
882 hdr
.cth_objtidxoff
= hdr
.cth_funcoff
+ func_size
;
883 hdr
.cth_funcidxoff
= hdr
.cth_objtidxoff
+ objtidx_size
;
884 hdr
.cth_varoff
= hdr
.cth_funcidxoff
+ funcidx_size
;
885 hdr
.cth_typeoff
= hdr
.cth_varoff
+ (nvars
* sizeof (ctf_varent_t
));
886 hdr
.cth_stroff
= hdr
.cth_typeoff
+ type_size
;
889 buf_size
= sizeof (ctf_header_t
) + hdr
.cth_stroff
+ hdr
.cth_strlen
;
891 if ((buf
= malloc (buf_size
)) == NULL
)
892 return (ctf_set_errno (fp
, EAGAIN
));
894 memcpy (buf
, &hdr
, sizeof (ctf_header_t
));
895 t
= (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_objtoff
;
897 hdrp
= (ctf_header_t
*) buf
;
898 if ((fp
->ctf_flags
& LCTF_CHILD
) && (fp
->ctf_parname
!= NULL
))
899 ctf_str_add_ref (fp
, fp
->ctf_parname
, &hdrp
->cth_parname
);
900 if (fp
->ctf_cuname
!= NULL
)
901 ctf_str_add_ref (fp
, fp
->ctf_cuname
, &hdrp
->cth_cuname
);
903 /* Sort the linker's symbols into name order if need be. */
905 if ((objtidx_size
!= 0) || (funcidx_size
!= 0))
907 ctf_next_t
*i
= NULL
;
913 if (symfp
->ctf_dynsyms
)
914 nsymtypes
= ctf_dynhash_elements (symfp
->ctf_dynsyms
);
919 nsymtypes
= ctf_dynhash_elements (fp
->ctf_objthash
)
920 + ctf_dynhash_elements (fp
->ctf_funchash
);
922 if ((sym_name_order
= calloc (nsymtypes
, sizeof (const char *))) == NULL
)
925 walk
= sym_name_order
;
929 if (symfp
->ctf_dynsyms
)
931 while ((err
= ctf_dynhash_next_sorted (symfp
->ctf_dynsyms
, &i
,
933 ctf_dynhash_sort_by_name
,
935 *walk
++ = (const char *) symname
;
936 if (err
!= ECTF_NEXT_END
)
942 ctf_hash_sort_f sort_fun
= NULL
;
944 /* Since we partition the set of symbols back into objt and func,
945 we can sort the two independently without harm. */
947 sort_fun
= ctf_dynhash_sort_by_name
;
949 while ((err
= ctf_dynhash_next_sorted (fp
->ctf_objthash
, &i
, &symname
,
950 NULL
, sort_fun
, NULL
)) == 0)
951 *walk
++ = (const char *) symname
;
952 if (err
!= ECTF_NEXT_END
)
955 while ((err
= ctf_dynhash_next_sorted (fp
->ctf_funchash
, &i
, &symname
,
956 NULL
, sort_fun
, NULL
)) == 0)
957 *walk
++ = (const char *) symname
;
958 if (err
!= ECTF_NEXT_END
)
963 /* Emit the object and function sections, and if necessary their indexes.
964 Emission is done in symtab order if there is no index, and in index
965 (name) order otherwise. */
967 if ((objtidx_size
== 0) && symfp
&& symfp
->ctf_dynsymidx
)
969 ctf_dprintf ("Emitting unindexed objt symtypetab\n");
970 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
971 NULL
, symfp
->ctf_dynsymmax
+ 1, maxobjt
, objt_size
,
972 symflags
| CTF_SYMTYPETAB_EMIT_PAD
) < 0)
973 goto err
; /* errno is set for us. */
977 ctf_dprintf ("Emitting indexed objt symtypetab\n");
978 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
979 nsymtypes
, maxobjt
, objt_size
, symflags
) < 0)
980 goto err
; /* errno is set for us. */
985 if ((funcidx_size
== 0) && symfp
&& symfp
->ctf_dynsymidx
)
987 ctf_dprintf ("Emitting unindexed func symtypetab\n");
988 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
989 NULL
, symfp
->ctf_dynsymmax
+ 1, maxfunc
,
990 func_size
, symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
991 | CTF_SYMTYPETAB_EMIT_PAD
) < 0)
992 goto err
; /* errno is set for us. */
996 ctf_dprintf ("Emitting indexed func symtypetab\n");
997 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
998 nsymtypes
, maxfunc
, func_size
,
999 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
1000 goto err
; /* errno is set for us. */
1005 if (objtidx_size
> 0)
1006 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
1007 nsymtypes
, objtidx_size
, symflags
) < 0)
1012 if (funcidx_size
> 0)
1013 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
1014 nsymtypes
, funcidx_size
,
1015 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
1019 free (sym_name_order
);
1020 sym_name_order
= NULL
;
1022 /* Work over the variable list, translating everything into ctf_varent_t's and
1023 prepping the string table. */
1025 dvarents
= (ctf_varent_t
*) t
;
1026 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
1027 dvd
= ctf_list_next (dvd
), i
++)
1029 ctf_varent_t
*var
= &dvarents
[i
];
1031 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
1032 var
->ctv_type
= (uint32_t) dvd
->dvd_type
;
1034 assert (i
== nvars
);
1036 t
+= sizeof (ctf_varent_t
) * nvars
;
1038 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
1040 /* We now take a final lap through the dynamic type definition list and copy
1041 the appropriate type records to the output buffer, noting down the
1042 strings as we go. */
1044 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
1045 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
1047 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1048 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1053 ctf_stype_t
*copied
;
1056 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
1057 len
= sizeof (ctf_stype_t
);
1059 len
= sizeof (ctf_type_t
);
1061 memcpy (t
, &dtd
->dtd_data
, len
);
1062 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
1063 if (copied
->ctt_name
1064 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
1065 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
1072 if (kind
== CTF_K_INTEGER
)
1074 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1075 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1076 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1080 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1081 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1082 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1084 memcpy (t
, &encoding
, sizeof (encoding
));
1085 t
+= sizeof (encoding
);
1089 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
1090 t
+= sizeof (struct ctf_slice
);
1094 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
1095 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
1096 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
1097 memcpy (t
, &cta
, sizeof (cta
));
1101 case CTF_K_FUNCTION
:
1103 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
1106 for (argc
= 0; argc
< vlen
; argc
++)
1107 *argv
++ = dtd
->dtd_u
.dtu_argv
[argc
];
1110 *argv
++ = 0; /* Pad to 4-byte boundary. */
1112 t
= (unsigned char *) argv
;
1118 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
1119 t
= ctf_copy_smembers (fp
, dtd
, t
);
1121 t
= ctf_copy_lmembers (fp
, dtd
, t
);
1125 t
= ctf_copy_emembers (fp
, dtd
, t
);
1129 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
1131 /* Construct the final string table and fill out all the string refs with the
1132 final offsets. Then purge the refs list, because we're about to move this
1133 strtab onto the end of the buf, invalidating all the offsets. */
1134 strtab
= ctf_str_write_strtab (fp
);
1135 ctf_str_purge_refs (fp
);
1137 if (strtab
.cts_strs
== NULL
)
1140 /* Now the string table is constructed, we can sort the buffer of
1142 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
1143 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
1146 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
1148 free (strtab
.cts_strs
);
1152 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
1153 hdrp
= (ctf_header_t
*) buf
;
1154 hdrp
->cth_strlen
= strtab
.cts_len
;
1155 buf_size
+= hdrp
->cth_strlen
;
1156 free (strtab
.cts_strs
);
1158 /* Finally, we are ready to ctf_simple_open() the new dict. If this is
1159 successful, we then switch nfp and fp and free the old dict. */
1161 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
1162 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
1166 return (ctf_set_errno (fp
, err
));
1169 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
1171 nfp
->ctf_parent
= fp
->ctf_parent
;
1172 nfp
->ctf_parent_unreffed
= fp
->ctf_parent_unreffed
;
1173 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
1174 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
1175 if (nfp
->ctf_dynbase
== NULL
)
1176 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
1177 nfp
->ctf_dthash
= fp
->ctf_dthash
;
1178 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
1179 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
1180 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
1181 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
1182 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
1183 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
1184 nfp
->ctf_specific
= fp
->ctf_specific
;
1185 nfp
->ctf_nfuncidx
= fp
->ctf_nfuncidx
;
1186 nfp
->ctf_nobjtidx
= fp
->ctf_nobjtidx
;
1187 nfp
->ctf_objthash
= fp
->ctf_objthash
;
1188 nfp
->ctf_funchash
= fp
->ctf_funchash
;
1189 nfp
->ctf_dynsyms
= fp
->ctf_dynsyms
;
1190 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
1191 nfp
->ctf_pptrtab
= fp
->ctf_pptrtab
;
1192 nfp
->ctf_dynsymidx
= fp
->ctf_dynsymidx
;
1193 nfp
->ctf_dynsymmax
= fp
->ctf_dynsymmax
;
1194 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
1195 nfp
->ctf_pptrtab_len
= fp
->ctf_pptrtab_len
;
1196 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
1197 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
1198 nfp
->ctf_errs_warnings
= fp
->ctf_errs_warnings
;
1199 nfp
->ctf_funcidx_names
= fp
->ctf_funcidx_names
;
1200 nfp
->ctf_objtidx_names
= fp
->ctf_objtidx_names
;
1201 nfp
->ctf_funcidx_sxlate
= fp
->ctf_funcidx_sxlate
;
1202 nfp
->ctf_objtidx_sxlate
= fp
->ctf_objtidx_sxlate
;
1203 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
1204 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
1205 nfp
->ctf_pptrtab_typemax
= fp
->ctf_pptrtab_typemax
;
1206 nfp
->ctf_in_flight_dynsyms
= fp
->ctf_in_flight_dynsyms
;
1207 nfp
->ctf_link_in_cu_mapping
= fp
->ctf_link_in_cu_mapping
;
1208 nfp
->ctf_link_out_cu_mapping
= fp
->ctf_link_out_cu_mapping
;
1209 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
1210 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
1211 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
1212 nfp
->ctf_link_variable_filter
= fp
->ctf_link_variable_filter
;
1213 nfp
->ctf_link_variable_filter_arg
= fp
->ctf_link_variable_filter_arg
;
1214 nfp
->ctf_symsect_little_endian
= fp
->ctf_symsect_little_endian
;
1215 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
1216 nfp
->ctf_dedup_atoms
= fp
->ctf_dedup_atoms
;
1217 nfp
->ctf_dedup_atoms_alloc
= fp
->ctf_dedup_atoms_alloc
;
1218 memcpy (&nfp
->ctf_dedup
, &fp
->ctf_dedup
, sizeof (fp
->ctf_dedup
));
1220 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
1222 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
1223 nfp
->ctf_structs
= fp
->ctf_structs
;
1224 nfp
->ctf_unions
= fp
->ctf_unions
;
1225 nfp
->ctf_enums
= fp
->ctf_enums
;
1226 nfp
->ctf_names
= fp
->ctf_names
;
1228 fp
->ctf_dthash
= NULL
;
1229 ctf_str_free_atoms (nfp
);
1230 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
1231 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
1232 fp
->ctf_str_atoms
= NULL
;
1233 fp
->ctf_prov_strtab
= NULL
;
1234 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
1235 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
1236 fp
->ctf_add_processing
= NULL
;
1237 fp
->ctf_ptrtab
= NULL
;
1238 fp
->ctf_pptrtab
= NULL
;
1239 fp
->ctf_funcidx_names
= NULL
;
1240 fp
->ctf_objtidx_names
= NULL
;
1241 fp
->ctf_funcidx_sxlate
= NULL
;
1242 fp
->ctf_objtidx_sxlate
= NULL
;
1243 fp
->ctf_objthash
= NULL
;
1244 fp
->ctf_funchash
= NULL
;
1245 fp
->ctf_dynsyms
= NULL
;
1246 fp
->ctf_dynsymidx
= NULL
;
1247 fp
->ctf_link_inputs
= NULL
;
1248 fp
->ctf_link_outputs
= NULL
;
1249 fp
->ctf_syn_ext_strtab
= NULL
;
1250 fp
->ctf_link_in_cu_mapping
= NULL
;
1251 fp
->ctf_link_out_cu_mapping
= NULL
;
1252 fp
->ctf_link_type_mapping
= NULL
;
1253 fp
->ctf_dedup_atoms
= NULL
;
1254 fp
->ctf_dedup_atoms_alloc
= NULL
;
1255 fp
->ctf_parent_unreffed
= 1;
1257 fp
->ctf_dvhash
= NULL
;
1258 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
1259 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
1260 memset (&fp
->ctf_in_flight_dynsyms
, 0, sizeof (fp
->ctf_in_flight_dynsyms
));
1261 memset (&fp
->ctf_dedup
, 0, sizeof (fp
->ctf_dedup
));
1262 fp
->ctf_structs
.ctn_writable
= NULL
;
1263 fp
->ctf_unions
.ctn_writable
= NULL
;
1264 fp
->ctf_enums
.ctn_writable
= NULL
;
1265 fp
->ctf_names
.ctn_writable
= NULL
;
1267 memcpy (&ofp
, fp
, sizeof (ctf_dict_t
));
1268 memcpy (fp
, nfp
, sizeof (ctf_dict_t
));
1269 memcpy (nfp
, &ofp
, sizeof (ctf_dict_t
));
1271 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
1272 ctf_dict_close (nfp
);
1277 ctf_err_warn (fp
, 0, err
, _("error serializing symtypetabs"));
1281 free (sym_name_order
);
1282 return (ctf_set_errno (fp
, EAGAIN
));
1285 free (sym_name_order
);
1286 return -1; /* errno is set for us. */
1290 ctf_name_table (ctf_dict_t
*fp
, int kind
)
1295 return &fp
->ctf_structs
;
1297 return &fp
->ctf_unions
;
1299 return &fp
->ctf_enums
;
1301 return &fp
->ctf_names
;
1306 ctf_dtd_insert (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
1309 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
,
1312 ctf_set_errno (fp
, ENOMEM
);
1316 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
1317 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
1319 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
1320 (char *) name
, (void *) (uintptr_t)
1323 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t)
1325 ctf_set_errno (fp
, ENOMEM
);
1329 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
1334 ctf_dtd_delete (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
)
1336 ctf_dmdef_t
*dmd
, *nmd
;
1337 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1338 int name_kind
= kind
;
1341 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1348 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1349 dmd
!= NULL
; dmd
= nmd
)
1351 if (dmd
->dmd_name
!= NULL
)
1352 free (dmd
->dmd_name
);
1353 nmd
= ctf_list_next (dmd
);
1357 case CTF_K_FUNCTION
:
1358 free (dtd
->dtd_u
.dtu_argv
);
1361 name_kind
= dtd
->dtd_data
.ctt_type
;
1365 if (dtd
->dtd_data
.ctt_name
1366 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1367 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1369 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
1371 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1374 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
1379 ctf_dtd_lookup (const ctf_dict_t
*fp
, ctf_id_t type
)
1381 return (ctf_dtdef_t
*)
1382 ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) (uintptr_t) type
);
1386 ctf_dynamic_type (const ctf_dict_t
*fp
, ctf_id_t id
)
1390 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1393 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
1394 fp
= fp
->ctf_parent
;
1396 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
1398 if ((unsigned long) idx
<= fp
->ctf_typemax
)
1399 return ctf_dtd_lookup (fp
, id
);
1404 ctf_dvd_insert (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1406 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
1408 ctf_set_errno (fp
, ENOMEM
);
1411 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
1416 ctf_dvd_delete (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1418 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
1419 free (dvd
->dvd_name
);
1421 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
1426 ctf_dvd_lookup (const ctf_dict_t
*fp
, const char *name
)
1428 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
1431 /* Discard all of the dynamic type definitions and variable definitions that
1432 have been added to the dict since the last call to ctf_update(). We locate
1433 such types by scanning the dtd list and deleting elements that have type IDs
1434 greater than ctf_dtoldid, which is set by ctf_update(), above, and by
1435 scanning the variable list and deleting elements that have update IDs equal
1436 to the current value of the last-update snapshot count (indicating that they
1437 were added after the most recent call to ctf_update()). */
1439 ctf_discard (ctf_dict_t
*fp
)
1441 ctf_snapshot_id_t last_update
=
1443 fp
->ctf_snapshot_lu
+ 1 };
1445 /* Update required? */
1446 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
1449 return (ctf_rollback (fp
, last_update
));
1453 ctf_snapshot (ctf_dict_t
*fp
)
1455 ctf_snapshot_id_t snapid
;
1456 snapid
.dtd_id
= fp
->ctf_typemax
;
1457 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
1461 /* Like ctf_discard(), only discards everything after a particular ID. */
1463 ctf_rollback (ctf_dict_t
*fp
, ctf_snapshot_id_t id
)
1465 ctf_dtdef_t
*dtd
, *ntd
;
1466 ctf_dvdef_t
*dvd
, *nvd
;
1468 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1469 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1471 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
1472 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
1474 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1479 ntd
= ctf_list_next (dtd
);
1481 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
1484 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1485 if (kind
== CTF_K_FORWARD
)
1486 kind
= dtd
->dtd_data
.ctt_type
;
1488 if (dtd
->dtd_data
.ctt_name
1489 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1490 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1492 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
1494 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1497 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1498 ctf_dtd_delete (fp
, dtd
);
1501 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1503 nvd
= ctf_list_next (dvd
);
1505 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
1508 ctf_dvd_delete (fp
, dvd
);
1511 fp
->ctf_typemax
= id
.dtd_id
;
1512 fp
->ctf_snapshots
= id
.snapshot_id
;
1514 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
1515 fp
->ctf_flags
&= ~LCTF_DIRTY
;
1521 ctf_add_generic (ctf_dict_t
*fp
, uint32_t flag
, const char *name
, int kind
,
1527 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
1528 return (ctf_set_errno (fp
, EINVAL
));
1530 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1531 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1533 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
1534 return (ctf_set_errno (fp
, ECTF_FULL
));
1536 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
1537 return (ctf_set_errno (fp
, ECTF_FULL
));
1539 /* Make sure ptrtab always grows to be big enough for all types. */
1540 if (ctf_grow_ptrtab (fp
) < 0)
1541 return CTF_ERR
; /* errno is set for us. */
1543 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
1544 return (ctf_set_errno (fp
, EAGAIN
));
1546 type
= ++fp
->ctf_typemax
;
1547 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
1549 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
1550 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1551 dtd
->dtd_type
= type
;
1553 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
1556 return (ctf_set_errno (fp
, EAGAIN
));
1559 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
1562 return CTF_ERR
; /* errno is set for us. */
1564 fp
->ctf_flags
|= LCTF_DIRTY
;
1570 /* When encoding integer sizes, we want to convert a byte count in the range
1571 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
1572 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
1588 ctf_add_encoded (ctf_dict_t
*fp
, uint32_t flag
,
1589 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
1595 return (ctf_set_errno (fp
, EINVAL
));
1597 if (name
== NULL
|| name
[0] == '\0')
1598 return (ctf_set_errno (fp
, ECTF_NONAME
));
1600 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1601 return CTF_ERR
; /* errno is set for us. */
1603 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1604 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1606 dtd
->dtd_u
.dtu_enc
= *ep
;
1612 ctf_add_reftype (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
1616 ctf_dict_t
*tmp
= fp
;
1617 int child
= fp
->ctf_flags
& LCTF_CHILD
;
1619 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1620 return (ctf_set_errno (fp
, EINVAL
));
1622 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1623 return CTF_ERR
; /* errno is set for us. */
1625 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
1626 return CTF_ERR
; /* errno is set for us. */
1628 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1629 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1631 if (kind
!= CTF_K_POINTER
)
1634 /* If we are adding a pointer, update the ptrtab, pointing at this type from
1635 the type it points to. Note that ctf_typemax is at this point one higher
1636 than we want to check against, because it's just been incremented for the
1637 addition of this type. The pptrtab is lazily-updated as needed, so is not
1640 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
1641 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
1643 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
1644 && ref_idx
< fp
->ctf_typemax
)
1645 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
1651 ctf_add_slice (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
,
1652 const ctf_encoding_t
*ep
)
1655 ctf_id_t resolved_ref
= ref
;
1658 const ctf_type_t
*tp
;
1659 ctf_dict_t
*tmp
= fp
;
1662 return (ctf_set_errno (fp
, EINVAL
));
1664 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
1665 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
1667 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1668 return (ctf_set_errno (fp
, EINVAL
));
1670 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
1671 return CTF_ERR
; /* errno is set for us. */
1673 /* Make sure we ultimately point to an integral type. We also allow slices to
1674 point to the unimplemented type, for now, because the compiler can emit
1675 such slices, though they're not very much use. */
1677 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
1678 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
1680 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
1681 (kind
!= CTF_K_ENUM
)
1683 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1685 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
1686 return CTF_ERR
; /* errno is set for us. */
1688 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
1689 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1691 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
1692 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
1693 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
1699 ctf_add_integer (ctf_dict_t
*fp
, uint32_t flag
,
1700 const char *name
, const ctf_encoding_t
*ep
)
1702 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1706 ctf_add_float (ctf_dict_t
*fp
, uint32_t flag
,
1707 const char *name
, const ctf_encoding_t
*ep
)
1709 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1713 ctf_add_pointer (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1715 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1719 ctf_add_array (ctf_dict_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1723 ctf_dict_t
*tmp
= fp
;
1726 return (ctf_set_errno (fp
, EINVAL
));
1728 if (arp
->ctr_contents
!= 0
1729 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1730 return CTF_ERR
; /* errno is set for us. */
1733 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1734 return CTF_ERR
; /* errno is set for us. */
1736 if (ctf_type_kind (fp
, arp
->ctr_index
) == CTF_K_FORWARD
)
1738 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
1739 _("ctf_add_array: index type %lx is incomplete"),
1741 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
1744 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1745 return CTF_ERR
; /* errno is set for us. */
1747 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1748 dtd
->dtd_data
.ctt_size
= 0;
1749 dtd
->dtd_u
.dtu_arr
= *arp
;
1755 ctf_set_array (ctf_dict_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1757 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1759 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1760 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1763 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1764 return (ctf_set_errno (fp
, ECTF_BADID
));
1766 fp
->ctf_flags
|= LCTF_DIRTY
;
1767 dtd
->dtd_u
.dtu_arr
= *arp
;
1773 ctf_add_function (ctf_dict_t
*fp
, uint32_t flag
,
1774 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1779 uint32_t *vdat
= NULL
;
1780 ctf_dict_t
*tmp
= fp
;
1783 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1784 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1786 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1787 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1788 return (ctf_set_errno (fp
, EINVAL
));
1790 vlen
= ctc
->ctc_argc
;
1791 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1792 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1794 if (ctc
->ctc_return
!= 0
1795 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1796 return CTF_ERR
; /* errno is set for us. */
1798 if (vlen
> CTF_MAX_VLEN
)
1799 return (ctf_set_errno (fp
, EOVERFLOW
));
1801 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1802 return (ctf_set_errno (fp
, EAGAIN
));
1804 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1807 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1810 return CTF_ERR
; /* errno is set for us. */
1812 vdat
[i
] = (uint32_t) argv
[i
];
1815 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1819 return CTF_ERR
; /* errno is set for us. */
1822 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1823 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1825 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1826 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1827 dtd
->dtd_u
.dtu_argv
= vdat
;
1833 ctf_add_struct_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1839 /* Promote root-visible forwards to structs. */
1841 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1843 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1844 dtd
= ctf_dtd_lookup (fp
, type
);
1845 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1847 return CTF_ERR
; /* errno is set for us. */
1849 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1851 if (size
> CTF_MAX_SIZE
)
1853 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1854 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1855 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1858 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1864 ctf_add_struct (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1866 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1870 ctf_add_union_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1876 /* Promote root-visible forwards to unions. */
1878 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1880 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1881 dtd
= ctf_dtd_lookup (fp
, type
);
1882 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1884 return CTF_ERR
; /* errno is set for us */
1886 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1888 if (size
> CTF_MAX_SIZE
)
1890 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1891 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1892 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1895 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1901 ctf_add_union (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1903 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1907 ctf_add_enum (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1912 /* Promote root-visible forwards to enums. */
1914 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1916 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1917 dtd
= ctf_dtd_lookup (fp
, type
);
1918 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1920 return CTF_ERR
; /* errno is set for us. */
1922 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1923 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1929 ctf_add_enum_encoded (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1930 const ctf_encoding_t
*ep
)
1934 /* First, create the enum if need be, using most of the same machinery as
1935 ctf_add_enum(), to ensure that we do not allow things past that are not
1936 enums or forwards to them. (This includes other slices: you cannot slice a
1937 slice, which would be a useless thing to do anyway.) */
1940 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1944 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1945 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1946 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1948 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1949 return CTF_ERR
; /* errno is set for us. */
1951 /* Now attach a suitable slice to it. */
1953 return ctf_add_slice (fp
, flag
, type
, ep
);
1957 ctf_add_forward (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1963 if (!ctf_forwardable_kind (kind
))
1964 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1966 if (name
== NULL
|| name
[0] == '\0')
1967 return (ctf_set_errno (fp
, ECTF_NONAME
));
1969 /* If the type is already defined or exists as a forward tag, just
1970 return the ctf_id_t of the existing definition. */
1972 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1977 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1978 return CTF_ERR
; /* errno is set for us. */
1980 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1981 dtd
->dtd_data
.ctt_type
= kind
;
1987 ctf_add_typedef (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1992 ctf_dict_t
*tmp
= fp
;
1994 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1995 return (ctf_set_errno (fp
, EINVAL
));
1997 if (name
== NULL
|| name
[0] == '\0')
1998 return (ctf_set_errno (fp
, ECTF_NONAME
));
2000 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
2001 return CTF_ERR
; /* errno is set for us. */
2003 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
2005 return CTF_ERR
; /* errno is set for us. */
2007 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
2008 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
2014 ctf_add_volatile (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2016 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
2020 ctf_add_const (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2022 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
2026 ctf_add_restrict (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2028 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
2032 ctf_add_enumerator (ctf_dict_t
*fp
, ctf_id_t enid
, const char *name
,
2035 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
2038 uint32_t kind
, vlen
, root
;
2042 return (ctf_set_errno (fp
, EINVAL
));
2044 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2045 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2048 return (ctf_set_errno (fp
, ECTF_BADID
));
2050 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2051 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2052 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2054 if (kind
!= CTF_K_ENUM
)
2055 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
2057 if (vlen
== CTF_MAX_VLEN
)
2058 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2060 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2061 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2063 if (strcmp (dmd
->dmd_name
, name
) == 0)
2064 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2067 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2068 return (ctf_set_errno (fp
, EAGAIN
));
2070 if ((s
= strdup (name
)) == NULL
)
2073 return (ctf_set_errno (fp
, EAGAIN
));
2077 dmd
->dmd_type
= CTF_ERR
;
2078 dmd
->dmd_offset
= 0;
2079 dmd
->dmd_value
= value
;
2081 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2082 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2084 fp
->ctf_flags
|= LCTF_DIRTY
;
2090 ctf_add_member_offset (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2091 ctf_id_t type
, unsigned long bit_offset
)
2093 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
2096 ssize_t msize
, malign
, ssize
;
2097 uint32_t kind
, vlen
, root
;
2099 int is_incomplete
= 0;
2101 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2102 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2105 return (ctf_set_errno (fp
, ECTF_BADID
));
2107 if (name
!= NULL
&& name
[0] == '\0')
2110 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2111 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2112 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2114 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
2115 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
2117 if (vlen
== CTF_MAX_VLEN
)
2118 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2122 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2123 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2125 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
2126 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2130 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
2131 (malign
= ctf_type_align (fp
, type
)) < 0)
2133 /* The unimplemented type, and any type that resolves to it, has no size
2134 and no alignment: it can correspond to any number of compiler-inserted
2135 types. We allow incomplete types through since they are routinely
2136 added to the ends of structures, and can even be added elsewhere in
2137 structures by the deduplicator. They are assumed to be zero-size with
2138 no alignment: this is often wrong, but problems can be avoided in this
2139 case by explicitly specifying the size of the structure via the _sized
2140 functions. The deduplicator always does this. */
2144 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
2145 ctf_set_errno (fp
, 0);
2146 else if (ctf_errno (fp
) == ECTF_INCOMPLETE
)
2149 return -1; /* errno is set for us. */
2152 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2153 return (ctf_set_errno (fp
, EAGAIN
));
2155 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2158 return (ctf_set_errno (fp
, EAGAIN
));
2162 dmd
->dmd_type
= type
;
2163 dmd
->dmd_value
= -1;
2165 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
2167 if (bit_offset
== (unsigned long) - 1)
2169 /* Natural alignment. */
2171 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
2172 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
2173 size_t off
= lmd
->dmd_offset
;
2175 ctf_encoding_t linfo
;
2178 /* Propagate any error from ctf_type_resolve. If the last member was
2179 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
2180 cannot insert right after such a member without explicit offset
2181 specification, because its alignment and size is not known. */
2182 if (ltype
== CTF_ERR
)
2185 return -1; /* errno is set for us. */
2190 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2191 _("ctf_add_member_offset: cannot add member %s of "
2192 "incomplete type %lx to struct %lx without "
2193 "specifying explicit offset\n"),
2194 name
? name
: _("(unnamed member)"), type
, souid
);
2195 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
2198 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
2199 off
+= linfo
.cte_bits
;
2200 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
2201 off
+= lsize
* CHAR_BIT
;
2202 else if (lsize
== -1 && ctf_errno (fp
) == ECTF_INCOMPLETE
)
2204 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2205 _("ctf_add_member_offset: cannot add member %s of "
2206 "type %lx to struct %lx without specifying "
2207 "explicit offset after member %s of type %lx, "
2208 "which is an incomplete type\n"),
2209 name
? name
: _("(unnamed member)"), type
, souid
,
2210 lmd
->dmd_name
? lmd
->dmd_name
2211 : _("(unnamed member)"), ltype
);
2212 return -1; /* errno is set for us. */
2215 /* Round up the offset of the end of the last member to
2216 the next byte boundary, convert 'off' to bytes, and
2217 then round it up again to the next multiple of the
2218 alignment required by the new member. Finally,
2219 convert back to bits and store the result in
2220 dmd_offset. Technically we could do more efficient
2221 packing if the new member is a bit-field, but we're
2222 the "compiler" and ANSI says we can do as we choose. */
2224 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
2225 off
= roundup (off
, MAX (malign
, 1));
2226 dmd
->dmd_offset
= off
* CHAR_BIT
;
2227 ssize
= off
+ msize
;
2231 /* Specified offset in bits. */
2233 dmd
->dmd_offset
= bit_offset
;
2234 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2235 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
2240 dmd
->dmd_offset
= 0;
2241 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2242 ssize
= MAX (ssize
, msize
);
2245 if ((size_t) ssize
> CTF_MAX_SIZE
)
2247 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2248 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
2249 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
2252 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
2254 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2255 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2257 fp
->ctf_flags
|= LCTF_DIRTY
;
2262 ctf_add_member_encoded (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2263 ctf_id_t type
, unsigned long bit_offset
,
2264 const ctf_encoding_t encoding
)
2266 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
2267 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2270 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
2271 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
2273 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
2274 return -1; /* errno is set for us. */
2276 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
2280 ctf_add_member (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2283 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
2287 ctf_add_variable (ctf_dict_t
*fp
, const char *name
, ctf_id_t ref
)
2290 ctf_dict_t
*tmp
= fp
;
2292 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2293 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2295 if (ctf_dvd_lookup (fp
, name
) != NULL
)
2296 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2298 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
2299 return -1; /* errno is set for us. */
2301 /* Make sure this type is representable. */
2302 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
2303 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
2306 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
2307 return (ctf_set_errno (fp
, EAGAIN
));
2309 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
2312 return (ctf_set_errno (fp
, EAGAIN
));
2314 dvd
->dvd_type
= ref
;
2315 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
2317 if (ctf_dvd_insert (fp
, dvd
) < 0)
2319 free (dvd
->dvd_name
);
2321 return -1; /* errno is set for us. */
2324 fp
->ctf_flags
|= LCTF_DIRTY
;
2329 ctf_add_funcobjt_sym (ctf_dict_t
*fp
, int is_function
, const char *name
, ctf_id_t id
)
2331 ctf_dict_t
*tmp
= fp
;
2333 ctf_dynhash_t
*h
= is_function
? fp
->ctf_funchash
: fp
->ctf_objthash
;
2335 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2336 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2338 if (ctf_dynhash_lookup (fp
->ctf_objthash
, name
) != NULL
||
2339 ctf_dynhash_lookup (fp
->ctf_funchash
, name
) != NULL
)
2340 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2342 if (ctf_lookup_by_id (&tmp
, id
) == NULL
)
2343 return -1; /* errno is set for us. */
2345 if (is_function
&& ctf_type_kind (fp
, id
) != CTF_K_FUNCTION
)
2346 return (ctf_set_errno (fp
, ECTF_NOTFUNC
));
2348 if ((dupname
= strdup (name
)) == NULL
)
2349 return (ctf_set_errno (fp
, ENOMEM
));
2351 if (ctf_dynhash_insert (h
, dupname
, (void *) (uintptr_t) id
) < 0)
2354 return (ctf_set_errno (fp
, ENOMEM
));
2360 ctf_add_objt_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2362 return (ctf_add_funcobjt_sym (fp
, 0, name
, id
));
2366 ctf_add_func_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2368 return (ctf_add_funcobjt_sym (fp
, 1, name
, id
));
2371 typedef struct ctf_bundle
2373 ctf_dict_t
*ctb_dict
; /* CTF dict handle. */
2374 ctf_id_t ctb_type
; /* CTF type identifier. */
2375 ctf_dtdef_t
*ctb_dtd
; /* CTF dynamic type definition (if any). */
2379 enumcmp (const char *name
, int value
, void *arg
)
2381 ctf_bundle_t
*ctb
= arg
;
2384 if (ctf_enum_value (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &bvalue
) < 0)
2386 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2387 _("conflict due to enum %s iteration error"), name
);
2390 if (value
!= bvalue
)
2392 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2393 _("conflict due to enum value change: %i versus %i"),
2401 enumadd (const char *name
, int value
, void *arg
)
2403 ctf_bundle_t
*ctb
= arg
;
2405 return (ctf_add_enumerator (ctb
->ctb_dict
, ctb
->ctb_type
,
2410 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
2413 ctf_bundle_t
*ctb
= arg
;
2416 /* Don't check nameless members (e.g. anonymous structs/unions) against each
2421 if (ctf_member_info (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &ctm
) < 0)
2423 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2424 _("conflict due to struct member %s iteration error"),
2428 if (ctm
.ctm_offset
!= offset
)
2430 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2431 _("conflict due to struct member %s offset change: "
2433 name
, ctm
.ctm_offset
, offset
);
2440 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
2442 ctf_bundle_t
*ctb
= arg
;
2446 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2447 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2449 /* Unnamed members in non-dynamic dicts have a name of "", while dynamic dicts
2455 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2458 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2461 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
2462 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
2464 dmd
->dmd_type
= type
;
2465 dmd
->dmd_offset
= offset
;
2466 dmd
->dmd_value
= -1;
2468 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
2470 ctb
->ctb_dict
->ctf_flags
|= LCTF_DIRTY
;
2474 /* Record the correspondence between a source and ctf_add_type()-added
2475 destination type: both types are translated into parent type IDs if need be,
2476 so they relate to the actual dictionary they are in. Outside controlled
2477 circumstances (like linking) it is probably not useful to do more than
2478 compare these pointers, since there is nothing stopping the user closing the
2479 source dict whenever they want to.
2481 Our OOM handling here is just to not do anything, because this is called deep
2482 enough in the call stack that doing anything useful is painfully difficult:
2483 the worst consequence if we do OOM is a bit of type duplication anyway. */
2486 ctf_add_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2487 ctf_dict_t
*dst_fp
, ctf_id_t dst_type
)
2489 if (LCTF_TYPE_ISPARENT (src_fp
, src_type
) && src_fp
->ctf_parent
)
2490 src_fp
= src_fp
->ctf_parent
;
2492 src_type
= LCTF_TYPE_TO_INDEX(src_fp
, src_type
);
2494 if (LCTF_TYPE_ISPARENT (dst_fp
, dst_type
) && dst_fp
->ctf_parent
)
2495 dst_fp
= dst_fp
->ctf_parent
;
2497 dst_type
= LCTF_TYPE_TO_INDEX(dst_fp
, dst_type
);
2499 if (dst_fp
->ctf_link_type_mapping
== NULL
)
2501 ctf_hash_fun f
= ctf_hash_type_key
;
2502 ctf_hash_eq_fun e
= ctf_hash_eq_type_key
;
2504 if ((dst_fp
->ctf_link_type_mapping
= ctf_dynhash_create (f
, e
, free
,
2509 ctf_link_type_key_t
*key
;
2510 key
= calloc (1, sizeof (struct ctf_link_type_key
));
2514 key
->cltk_fp
= src_fp
;
2515 key
->cltk_idx
= src_type
;
2517 /* No OOM checking needed, because if this doesn't work the worst we'll do is
2518 add a few more duplicate types (which will probably run out of memory
2520 ctf_dynhash_insert (dst_fp
->ctf_link_type_mapping
, key
,
2521 (void *) (uintptr_t) dst_type
);
2524 /* Look up a type mapping: return 0 if none. The DST_FP is modified to point to
2525 the parent if need be. The ID returned is from the dst_fp's perspective. */
2527 ctf_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
, ctf_dict_t
**dst_fp
)
2529 ctf_link_type_key_t key
;
2530 ctf_dict_t
*target_fp
= *dst_fp
;
2531 ctf_id_t dst_type
= 0;
2533 if (LCTF_TYPE_ISPARENT (src_fp
, src_type
) && src_fp
->ctf_parent
)
2534 src_fp
= src_fp
->ctf_parent
;
2536 src_type
= LCTF_TYPE_TO_INDEX(src_fp
, src_type
);
2537 key
.cltk_fp
= src_fp
;
2538 key
.cltk_idx
= src_type
;
2540 if (target_fp
->ctf_link_type_mapping
)
2541 dst_type
= (uintptr_t) ctf_dynhash_lookup (target_fp
->ctf_link_type_mapping
,
2546 dst_type
= LCTF_INDEX_TO_TYPE (target_fp
, dst_type
,
2547 target_fp
->ctf_parent
!= NULL
);
2548 *dst_fp
= target_fp
;
2552 if (target_fp
->ctf_parent
)
2553 target_fp
= target_fp
->ctf_parent
;
2557 if (target_fp
->ctf_link_type_mapping
)
2558 dst_type
= (uintptr_t) ctf_dynhash_lookup (target_fp
->ctf_link_type_mapping
,
2562 dst_type
= LCTF_INDEX_TO_TYPE (target_fp
, dst_type
,
2563 target_fp
->ctf_parent
!= NULL
);
2565 *dst_fp
= target_fp
;
2569 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
2570 to a dynamic destination dictionary. This routine operates recursively by
2571 following the source type's links and embedded member types. If the
2572 destination dict already contains a named type which has the same attributes,
2573 then we succeed and return this type but no changes occur. */
2575 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2576 ctf_dict_t
*proc_tracking_fp
)
2578 ctf_id_t dst_type
= CTF_ERR
;
2579 uint32_t dst_kind
= CTF_K_UNKNOWN
;
2580 ctf_dict_t
*tmp_fp
= dst_fp
;
2584 uint32_t kind
, forward_kind
, flag
, vlen
;
2586 const ctf_type_t
*src_tp
, *dst_tp
;
2587 ctf_bundle_t src
, dst
;
2588 ctf_encoding_t src_en
, dst_en
;
2589 ctf_arinfo_t src_ar
, dst_ar
;
2593 ctf_id_t orig_src_type
= src_type
;
2595 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
2596 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
2598 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
2599 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2601 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
2602 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
2603 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
2605 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
2606 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
2607 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
2608 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
2610 /* If this is a type we are currently in the middle of adding, hand it
2611 straight back. (This lets us handle self-referential structures without
2612 considering forwards and empty structures the same as their completed
2615 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
2619 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
2620 (void *) (uintptr_t) src_type
))
2623 /* If this type has already been added from this dictionary, and is the
2624 same kind and (if a struct or union) has the same number of members,
2625 hand it straight back. */
2627 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
2629 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
2630 || kind
== CTF_K_ENUM
)
2632 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
2633 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
2641 forward_kind
= kind
;
2642 if (kind
== CTF_K_FORWARD
)
2643 forward_kind
= src_tp
->ctt_type
;
2645 /* If the source type has a name and is a root type (visible at the top-level
2646 scope), lookup the name in the destination dictionary and verify that it is
2647 of the same kind before we do anything else. */
2649 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
2650 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
2653 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
2656 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
2657 unless dst_type is a forward declaration and src_type is a struct,
2658 union, or enum (i.e. the definition of the previous forward decl).
2660 We also allow addition in the opposite order (addition of a forward when a
2661 struct, union, or enum already exists), which is a NOP and returns the
2662 already-present struct, union, or enum. */
2664 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
2666 if (kind
== CTF_K_FORWARD
2667 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
2668 || dst_kind
== CTF_K_UNION
))
2670 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2674 if (dst_kind
!= CTF_K_FORWARD
2675 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
2676 && kind
!= CTF_K_UNION
))
2678 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2679 _("ctf_add_type: conflict for type %s: "
2680 "kinds differ, new: %i; old (ID %lx): %i"),
2681 name
, kind
, dst_type
, dst_kind
);
2682 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2686 /* We take special action for an integer, float, or slice since it is
2687 described not only by its name but also its encoding. For integers,
2688 bit-fields exploit this degeneracy. */
2690 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
2692 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
2693 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2695 if (dst_type
!= CTF_ERR
)
2697 ctf_dict_t
*fp
= dst_fp
;
2699 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
2702 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
2703 return CTF_ERR
; /* errno set for us. */
2705 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
2707 /* The type that we found in the hash is also root-visible. If
2708 the two types match then use the existing one; otherwise,
2709 declare a conflict. Note: slices are not certain to match
2710 even if there is no conflict: we must check the contained type
2713 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2715 if (kind
!= CTF_K_SLICE
)
2717 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2723 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2728 /* We found a non-root-visible type in the hash. If its encoding
2729 is the same, we can reuse it, unless it is a slice. */
2731 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2733 if (kind
!= CTF_K_SLICE
)
2735 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2743 src
.ctb_dict
= src_fp
;
2744 src
.ctb_type
= src_type
;
2747 dst
.ctb_dict
= dst_fp
;
2748 dst
.ctb_type
= dst_type
;
2751 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
2752 a new type with the same properties as src_type to dst_fp. If dst_type is
2753 not CTF_ERR, then we verify that dst_type has the same attributes as
2754 src_type. We recurse for embedded references. Before we start, we note
2755 that we are processing this type, to prevent infinite recursion: we do not
2756 re-process any type that appears in this list. The list is emptied
2757 wholesale at the end of processing everything in this recursive stack. */
2759 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
2760 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
2761 return ctf_set_errno (dst_fp
, ENOMEM
);
2766 /* If we found a match we will have either returned it or declared a
2768 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
2772 /* If we found a match we will have either returned it or declared a
2774 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
2778 /* We have checked for conflicting encodings: now try to add the
2780 src_type
= ctf_type_reference (src_fp
, src_type
);
2781 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2784 if (src_type
== CTF_ERR
)
2785 return CTF_ERR
; /* errno is set for us. */
2787 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
2791 case CTF_K_VOLATILE
:
2793 case CTF_K_RESTRICT
:
2794 src_type
= ctf_type_reference (src_fp
, src_type
);
2795 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2798 if (src_type
== CTF_ERR
)
2799 return CTF_ERR
; /* errno is set for us. */
2801 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
2805 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
2806 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2808 src_ar
.ctr_contents
=
2809 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
2811 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
2814 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
2816 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
2817 return CTF_ERR
; /* errno is set for us. */
2819 if (dst_type
!= CTF_ERR
)
2821 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
2822 return CTF_ERR
; /* errno is set for us. */
2824 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
2826 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2827 _("conflict for type %s against ID %lx: array info "
2828 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
2829 name
, dst_type
, src_ar
.ctr_contents
,
2830 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
2831 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
2833 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2837 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
2840 case CTF_K_FUNCTION
:
2841 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
2847 if (ctc
.ctc_return
== CTF_ERR
)
2848 return CTF_ERR
; /* errno is set for us. */
2850 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
2862 /* Technically to match a struct or union we need to check both
2863 ways (src members vs. dst, dst members vs. src) but we make
2864 this more optimal by only checking src vs. dst and comparing
2865 the total size of the structure (which we must do anyway)
2866 which covers the possibility of dst members not in src.
2867 This optimization can be defeated for unions, but is so
2868 pathological as to render it irrelevant for our purposes. */
2870 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2871 && dst_kind
!= CTF_K_FORWARD
)
2873 if (ctf_type_size (src_fp
, src_type
) !=
2874 ctf_type_size (dst_fp
, dst_type
))
2876 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2877 _("conflict for type %s against ID %lx: union "
2878 "size differs, old %li, new %li"), name
,
2879 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
2880 (long) ctf_type_size (dst_fp
, dst_type
));
2881 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2884 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
2886 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2887 _("conflict for type %s against ID %lx: members "
2888 "differ, see above"), name
, dst_type
);
2889 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2895 /* Unlike the other cases, copying structs and unions is done
2896 manually so as to avoid repeated lookups in ctf_add_member
2897 and to ensure the exact same member offsets as in src_type. */
2899 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2900 if (dst_type
== CTF_ERR
)
2901 return CTF_ERR
; /* errno is set for us. */
2903 dst
.ctb_type
= dst_type
;
2906 /* Pre-emptively add this struct to the type mapping so that
2907 structures that refer to themselves work. */
2908 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2910 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2911 errs
++; /* Increment errs and fail at bottom of case. */
2913 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2914 return CTF_ERR
; /* errno is set for us. */
2916 size
= (size_t) ssize
;
2917 if (size
> CTF_MAX_SIZE
)
2919 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2920 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2921 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2924 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2926 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2928 /* Make a final pass through the members changing each dmd_type (a
2929 src_fp type) to an equivalent type in dst_fp. We pass through all
2930 members, leaving any that fail set to CTF_ERR, unless they fail
2931 because they are marking a member of type not representable in this
2932 version of CTF, in which case we just want to silently omit them:
2933 no consumer can do anything with them anyway. */
2934 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2935 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2937 ctf_dict_t
*dst
= dst_fp
;
2940 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2943 if ((dmd
->dmd_type
=
2944 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2945 proc_tracking_fp
)) == CTF_ERR
)
2947 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2952 dmd
->dmd_type
= memb_type
;
2956 return CTF_ERR
; /* errno is set for us. */
2961 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2962 && dst_kind
!= CTF_K_FORWARD
)
2964 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2965 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2967 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2968 _("conflict for enum %s against ID %lx: members "
2969 "differ, see above"), name
, dst_type
);
2970 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2975 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2976 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2977 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2978 return CTF_ERR
; /* errno is set for us */
2983 if (dst_type
== CTF_ERR
)
2984 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2988 src_type
= ctf_type_reference (src_fp
, src_type
);
2989 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2992 if (src_type
== CTF_ERR
)
2993 return CTF_ERR
; /* errno is set for us. */
2995 /* If dst_type is not CTF_ERR at this point, we should check if
2996 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2997 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2998 that vary based on things like if 32-bit then pid_t is int otherwise
2999 long. We therefore omit this check and assume that if the identically
3000 named typedef already exists in dst_fp, it is correct or
3003 if (dst_type
== CTF_ERR
)
3004 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
3009 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
3012 if (dst_type
!= CTF_ERR
)
3013 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
3018 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
3022 if (!src_fp
->ctf_add_processing
)
3023 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
3024 ctf_hash_eq_integer
,
3027 /* We store the hash on the source, because it contains only source type IDs:
3028 but callers will invariably expect errors to appear on the dest. */
3029 if (!src_fp
->ctf_add_processing
)
3030 return (ctf_set_errno (dst_fp
, ENOMEM
));
3032 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
3033 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
3038 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
3040 ctf_gzwrite (ctf_dict_t
*fp
, gzFile fd
)
3042 const unsigned char *buf
;
3046 resid
= sizeof (ctf_header_t
);
3047 buf
= (unsigned char *) fp
->ctf_header
;
3050 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
3051 return (ctf_set_errno (fp
, errno
));
3056 resid
= fp
->ctf_size
;
3060 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
3061 return (ctf_set_errno (fp
, errno
));
3069 /* Compress the specified CTF data stream and write it to the specified file
3072 ctf_compress_write (ctf_dict_t
*fp
, int fd
)
3077 ctf_header_t
*hp
= &h
;
3078 ssize_t header_len
= sizeof (ctf_header_t
);
3079 ssize_t compress_len
;
3084 if (ctf_serialize (fp
) < 0)
3085 return -1; /* errno is set for us. */
3087 memcpy (hp
, fp
->ctf_header
, header_len
);
3088 hp
->cth_flags
|= CTF_F_COMPRESS
;
3089 compress_len
= compressBound (fp
->ctf_size
);
3091 if ((buf
= malloc (compress_len
)) == NULL
)
3093 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
3094 (unsigned long) compress_len
);
3095 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
3098 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
3099 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3101 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
3102 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3106 while (header_len
> 0)
3108 if ((len
= write (fd
, hp
, header_len
)) < 0)
3110 err
= ctf_set_errno (fp
, errno
);
3111 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing header"));
3119 while (compress_len
> 0)
3121 if ((len
= write (fd
, bp
, compress_len
)) < 0)
3123 err
= ctf_set_errno (fp
, errno
);
3124 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing"));
3127 compress_len
-= len
;
3136 /* Optionally compress the specified CTF data stream and return it as a new
3137 dynamically-allocated string. */
3139 ctf_write_mem (ctf_dict_t
*fp
, size_t *size
, size_t threshold
)
3144 ssize_t header_len
= sizeof (ctf_header_t
);
3145 ssize_t compress_len
;
3148 if (ctf_serialize (fp
) < 0)
3149 return NULL
; /* errno is set for us. */
3151 compress_len
= compressBound (fp
->ctf_size
);
3152 if (fp
->ctf_size
< threshold
)
3153 compress_len
= fp
->ctf_size
;
3154 if ((buf
= malloc (compress_len
3155 + sizeof (struct ctf_header
))) == NULL
)
3157 ctf_set_errno (fp
, ENOMEM
);
3158 ctf_err_warn (fp
, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
3159 (unsigned long) (compress_len
+ sizeof (struct ctf_header
)));
3163 hp
= (ctf_header_t
*) buf
;
3164 memcpy (hp
, fp
->ctf_header
, header_len
);
3165 bp
= buf
+ sizeof (struct ctf_header
);
3166 *size
= sizeof (struct ctf_header
);
3168 if (fp
->ctf_size
< threshold
)
3170 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
3171 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
3172 *size
+= fp
->ctf_size
;
3176 hp
->cth_flags
|= CTF_F_COMPRESS
;
3177 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
3178 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3180 ctf_set_errno (fp
, ECTF_COMPRESS
);
3181 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3185 *size
+= compress_len
;
3190 /* Write the uncompressed CTF data stream to the specified file descriptor. */
3192 ctf_write (ctf_dict_t
*fp
, int fd
)
3194 const unsigned char *buf
;
3198 if (ctf_serialize (fp
) < 0)
3199 return -1; /* errno is set for us. */
3201 resid
= sizeof (ctf_header_t
);
3202 buf
= (unsigned char *) fp
->ctf_header
;
3205 if ((len
= write (fd
, buf
, resid
)) <= 0)
3207 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing header"));
3208 return (ctf_set_errno (fp
, errno
));
3214 resid
= fp
->ctf_size
;
3218 if ((len
= write (fd
, buf
, resid
)) <= 0)
3220 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing"));
3221 return (ctf_set_errno (fp
, errno
));