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
;
914 if (symfp
->ctf_dynsyms
)
915 nsymtypes
= ctf_dynhash_elements (symfp
->ctf_dynsyms
);
920 nsymtypes
= ctf_dynhash_elements (fp
->ctf_objthash
)
921 + ctf_dynhash_elements (fp
->ctf_funchash
);
923 if ((sym_name_order
= calloc (nsymtypes
, sizeof (const char *))) == NULL
)
926 walk
= sym_name_order
;
930 if (symfp
->ctf_dynsyms
)
932 while ((err
= ctf_dynhash_next_sorted (symfp
->ctf_dynsyms
, &i
,
934 ctf_dynhash_sort_by_name
,
936 *walk
++ = (const char *) symname
;
937 if (err
!= ECTF_NEXT_END
)
943 ctf_hash_sort_f sort_fun
= NULL
;
945 /* Since we partition the set of symbols back into objt and func,
946 we can sort the two independently without harm. */
948 sort_fun
= ctf_dynhash_sort_by_name
;
950 while ((err
= ctf_dynhash_next_sorted (fp
->ctf_objthash
, &i
, &symname
,
951 NULL
, sort_fun
, NULL
)) == 0)
952 *walk
++ = (const char *) symname
;
953 if (err
!= ECTF_NEXT_END
)
956 while ((err
= ctf_dynhash_next_sorted (fp
->ctf_funchash
, &i
, &symname
,
957 NULL
, sort_fun
, NULL
)) == 0)
958 *walk
++ = (const char *) symname
;
959 if (err
!= ECTF_NEXT_END
)
964 /* Emit the object and function sections, and if necessary their indexes.
965 Emission is done in symtab order if there is no index, and in index
966 (name) order otherwise. */
968 if ((objtidx_size
== 0) && symfp
&& symfp
->ctf_dynsymidx
)
970 ctf_dprintf ("Emitting unindexed objt symtypetab\n");
971 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
972 NULL
, symfp
->ctf_dynsymmax
+ 1, maxobjt
, objt_size
,
973 symflags
| CTF_SYMTYPETAB_EMIT_PAD
) < 0)
974 goto err
; /* errno is set for us. */
978 ctf_dprintf ("Emitting indexed objt symtypetab\n");
979 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
980 nsymtypes
, maxobjt
, objt_size
, symflags
) < 0)
981 goto err
; /* errno is set for us. */
986 if ((funcidx_size
== 0) && symfp
&& symfp
->ctf_dynsymidx
)
988 ctf_dprintf ("Emitting unindexed func symtypetab\n");
989 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
990 NULL
, symfp
->ctf_dynsymmax
+ 1, maxfunc
,
991 func_size
, symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
992 | CTF_SYMTYPETAB_EMIT_PAD
) < 0)
993 goto err
; /* errno is set for us. */
997 ctf_dprintf ("Emitting indexed func symtypetab\n");
998 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
999 nsymtypes
, maxfunc
, func_size
,
1000 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
1001 goto err
; /* errno is set for us. */
1006 if (objtidx_size
> 0)
1007 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
1008 nsymtypes
, objtidx_size
, symflags
) < 0)
1013 if (funcidx_size
> 0)
1014 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
1015 nsymtypes
, funcidx_size
,
1016 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
1020 free (sym_name_order
);
1021 sym_name_order
= NULL
;
1023 /* Work over the variable list, translating everything into ctf_varent_t's and
1024 prepping the string table. */
1026 dvarents
= (ctf_varent_t
*) t
;
1027 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
1028 dvd
= ctf_list_next (dvd
), i
++)
1030 ctf_varent_t
*var
= &dvarents
[i
];
1032 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
1033 var
->ctv_type
= (uint32_t) dvd
->dvd_type
;
1035 assert (i
== nvars
);
1037 t
+= sizeof (ctf_varent_t
) * nvars
;
1039 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
1041 /* We now take a final lap through the dynamic type definition list and copy
1042 the appropriate type records to the output buffer, noting down the
1043 strings as we go. */
1045 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
1046 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
1048 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1049 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1054 ctf_stype_t
*copied
;
1057 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
1058 len
= sizeof (ctf_stype_t
);
1060 len
= sizeof (ctf_type_t
);
1062 memcpy (t
, &dtd
->dtd_data
, len
);
1063 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
1064 if (copied
->ctt_name
1065 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
1066 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
1073 if (kind
== CTF_K_INTEGER
)
1075 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1076 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1077 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1081 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1082 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1083 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1085 memcpy (t
, &encoding
, sizeof (encoding
));
1086 t
+= sizeof (encoding
);
1090 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
1091 t
+= sizeof (struct ctf_slice
);
1095 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
1096 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
1097 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
1098 memcpy (t
, &cta
, sizeof (cta
));
1102 case CTF_K_FUNCTION
:
1104 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
1107 for (argc
= 0; argc
< vlen
; argc
++)
1108 *argv
++ = dtd
->dtd_u
.dtu_argv
[argc
];
1111 *argv
++ = 0; /* Pad to 4-byte boundary. */
1113 t
= (unsigned char *) argv
;
1119 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
1120 t
= ctf_copy_smembers (fp
, dtd
, t
);
1122 t
= ctf_copy_lmembers (fp
, dtd
, t
);
1126 t
= ctf_copy_emembers (fp
, dtd
, t
);
1130 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
1132 /* Construct the final string table and fill out all the string refs with the
1133 final offsets. Then purge the refs list, because we're about to move this
1134 strtab onto the end of the buf, invalidating all the offsets. */
1135 strtab
= ctf_str_write_strtab (fp
);
1136 ctf_str_purge_refs (fp
);
1138 if (strtab
.cts_strs
== NULL
)
1141 /* Now the string table is constructed, we can sort the buffer of
1143 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
1144 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
1147 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
1149 free (strtab
.cts_strs
);
1153 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
1154 hdrp
= (ctf_header_t
*) buf
;
1155 hdrp
->cth_strlen
= strtab
.cts_len
;
1156 buf_size
+= hdrp
->cth_strlen
;
1157 free (strtab
.cts_strs
);
1159 /* Finally, we are ready to ctf_simple_open() the new dict. If this is
1160 successful, we then switch nfp and fp and free the old dict. */
1162 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
1163 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
1167 return (ctf_set_errno (fp
, err
));
1170 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
1172 nfp
->ctf_parent
= fp
->ctf_parent
;
1173 nfp
->ctf_parent_unreffed
= fp
->ctf_parent_unreffed
;
1174 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
1175 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
1176 if (nfp
->ctf_dynbase
== NULL
)
1177 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
1178 nfp
->ctf_dthash
= fp
->ctf_dthash
;
1179 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
1180 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
1181 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
1182 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
1183 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
1184 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
1185 nfp
->ctf_specific
= fp
->ctf_specific
;
1186 nfp
->ctf_nfuncidx
= fp
->ctf_nfuncidx
;
1187 nfp
->ctf_nobjtidx
= fp
->ctf_nobjtidx
;
1188 nfp
->ctf_objthash
= fp
->ctf_objthash
;
1189 nfp
->ctf_funchash
= fp
->ctf_funchash
;
1190 nfp
->ctf_dynsyms
= fp
->ctf_dynsyms
;
1191 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
1192 nfp
->ctf_pptrtab
= fp
->ctf_pptrtab
;
1193 nfp
->ctf_dynsymidx
= fp
->ctf_dynsymidx
;
1194 nfp
->ctf_dynsymmax
= fp
->ctf_dynsymmax
;
1195 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
1196 nfp
->ctf_pptrtab_len
= fp
->ctf_pptrtab_len
;
1197 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
1198 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
1199 nfp
->ctf_errs_warnings
= fp
->ctf_errs_warnings
;
1200 nfp
->ctf_funcidx_names
= fp
->ctf_funcidx_names
;
1201 nfp
->ctf_objtidx_names
= fp
->ctf_objtidx_names
;
1202 nfp
->ctf_funcidx_sxlate
= fp
->ctf_funcidx_sxlate
;
1203 nfp
->ctf_objtidx_sxlate
= fp
->ctf_objtidx_sxlate
;
1204 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
1205 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
1206 nfp
->ctf_pptrtab_typemax
= fp
->ctf_pptrtab_typemax
;
1207 nfp
->ctf_in_flight_dynsyms
= fp
->ctf_in_flight_dynsyms
;
1208 nfp
->ctf_link_in_cu_mapping
= fp
->ctf_link_in_cu_mapping
;
1209 nfp
->ctf_link_out_cu_mapping
= fp
->ctf_link_out_cu_mapping
;
1210 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
1211 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
1212 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
1213 nfp
->ctf_link_variable_filter
= fp
->ctf_link_variable_filter
;
1214 nfp
->ctf_link_variable_filter_arg
= fp
->ctf_link_variable_filter_arg
;
1215 nfp
->ctf_symsect_little_endian
= fp
->ctf_symsect_little_endian
;
1216 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
1217 nfp
->ctf_dedup_atoms
= fp
->ctf_dedup_atoms
;
1218 nfp
->ctf_dedup_atoms_alloc
= fp
->ctf_dedup_atoms_alloc
;
1219 memcpy (&nfp
->ctf_dedup
, &fp
->ctf_dedup
, sizeof (fp
->ctf_dedup
));
1221 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
1223 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
1224 nfp
->ctf_structs
= fp
->ctf_structs
;
1225 nfp
->ctf_unions
= fp
->ctf_unions
;
1226 nfp
->ctf_enums
= fp
->ctf_enums
;
1227 nfp
->ctf_names
= fp
->ctf_names
;
1229 fp
->ctf_dthash
= NULL
;
1230 ctf_str_free_atoms (nfp
);
1231 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
1232 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
1233 fp
->ctf_str_atoms
= NULL
;
1234 fp
->ctf_prov_strtab
= NULL
;
1235 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
1236 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
1237 fp
->ctf_add_processing
= NULL
;
1238 fp
->ctf_ptrtab
= NULL
;
1239 fp
->ctf_pptrtab
= NULL
;
1240 fp
->ctf_funcidx_names
= NULL
;
1241 fp
->ctf_objtidx_names
= NULL
;
1242 fp
->ctf_funcidx_sxlate
= NULL
;
1243 fp
->ctf_objtidx_sxlate
= NULL
;
1244 fp
->ctf_objthash
= NULL
;
1245 fp
->ctf_funchash
= NULL
;
1246 fp
->ctf_dynsyms
= NULL
;
1247 fp
->ctf_dynsymidx
= NULL
;
1248 fp
->ctf_link_inputs
= NULL
;
1249 fp
->ctf_link_outputs
= NULL
;
1250 fp
->ctf_syn_ext_strtab
= NULL
;
1251 fp
->ctf_link_in_cu_mapping
= NULL
;
1252 fp
->ctf_link_out_cu_mapping
= NULL
;
1253 fp
->ctf_link_type_mapping
= NULL
;
1254 fp
->ctf_dedup_atoms
= NULL
;
1255 fp
->ctf_dedup_atoms_alloc
= NULL
;
1256 fp
->ctf_parent_unreffed
= 1;
1258 fp
->ctf_dvhash
= NULL
;
1259 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
1260 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
1261 memset (&fp
->ctf_in_flight_dynsyms
, 0, sizeof (fp
->ctf_in_flight_dynsyms
));
1262 memset (&fp
->ctf_dedup
, 0, sizeof (fp
->ctf_dedup
));
1263 fp
->ctf_structs
.ctn_writable
= NULL
;
1264 fp
->ctf_unions
.ctn_writable
= NULL
;
1265 fp
->ctf_enums
.ctn_writable
= NULL
;
1266 fp
->ctf_names
.ctn_writable
= NULL
;
1268 memcpy (&ofp
, fp
, sizeof (ctf_dict_t
));
1269 memcpy (fp
, nfp
, sizeof (ctf_dict_t
));
1270 memcpy (nfp
, &ofp
, sizeof (ctf_dict_t
));
1272 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
1273 ctf_dict_close (nfp
);
1278 ctf_err_warn (fp
, 0, err
, _("error serializing symtypetabs"));
1282 free (sym_name_order
);
1283 return (ctf_set_errno (fp
, EAGAIN
));
1286 free (sym_name_order
);
1287 return -1; /* errno is set for us. */
1291 ctf_name_table (ctf_dict_t
*fp
, int kind
)
1296 return &fp
->ctf_structs
;
1298 return &fp
->ctf_unions
;
1300 return &fp
->ctf_enums
;
1302 return &fp
->ctf_names
;
1307 ctf_dtd_insert (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
1310 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
,
1313 ctf_set_errno (fp
, ENOMEM
);
1317 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
1318 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
1320 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
1321 (char *) name
, (void *) (uintptr_t)
1324 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t)
1326 ctf_set_errno (fp
, ENOMEM
);
1330 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
1335 ctf_dtd_delete (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
)
1337 ctf_dmdef_t
*dmd
, *nmd
;
1338 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1339 int name_kind
= kind
;
1342 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1349 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1350 dmd
!= NULL
; dmd
= nmd
)
1352 if (dmd
->dmd_name
!= NULL
)
1353 free (dmd
->dmd_name
);
1354 nmd
= ctf_list_next (dmd
);
1358 case CTF_K_FUNCTION
:
1359 free (dtd
->dtd_u
.dtu_argv
);
1362 name_kind
= dtd
->dtd_data
.ctt_type
;
1366 if (dtd
->dtd_data
.ctt_name
1367 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1368 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1370 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
1372 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1375 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
1380 ctf_dtd_lookup (const ctf_dict_t
*fp
, ctf_id_t type
)
1382 return (ctf_dtdef_t
*)
1383 ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) (uintptr_t) type
);
1387 ctf_dynamic_type (const ctf_dict_t
*fp
, ctf_id_t id
)
1391 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1394 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
1395 fp
= fp
->ctf_parent
;
1397 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
1399 if ((unsigned long) idx
<= fp
->ctf_typemax
)
1400 return ctf_dtd_lookup (fp
, id
);
1405 ctf_dvd_insert (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1407 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
1409 ctf_set_errno (fp
, ENOMEM
);
1412 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
1417 ctf_dvd_delete (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1419 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
1420 free (dvd
->dvd_name
);
1422 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
1427 ctf_dvd_lookup (const ctf_dict_t
*fp
, const char *name
)
1429 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
1432 /* Discard all of the dynamic type definitions and variable definitions that
1433 have been added to the dict since the last call to ctf_update(). We locate
1434 such types by scanning the dtd list and deleting elements that have type IDs
1435 greater than ctf_dtoldid, which is set by ctf_update(), above, and by
1436 scanning the variable list and deleting elements that have update IDs equal
1437 to the current value of the last-update snapshot count (indicating that they
1438 were added after the most recent call to ctf_update()). */
1440 ctf_discard (ctf_dict_t
*fp
)
1442 ctf_snapshot_id_t last_update
=
1444 fp
->ctf_snapshot_lu
+ 1 };
1446 /* Update required? */
1447 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
1450 return (ctf_rollback (fp
, last_update
));
1454 ctf_snapshot (ctf_dict_t
*fp
)
1456 ctf_snapshot_id_t snapid
;
1457 snapid
.dtd_id
= fp
->ctf_typemax
;
1458 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
1462 /* Like ctf_discard(), only discards everything after a particular ID. */
1464 ctf_rollback (ctf_dict_t
*fp
, ctf_snapshot_id_t id
)
1466 ctf_dtdef_t
*dtd
, *ntd
;
1467 ctf_dvdef_t
*dvd
, *nvd
;
1469 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1470 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1472 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
1473 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
1475 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1480 ntd
= ctf_list_next (dtd
);
1482 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
1485 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1486 if (kind
== CTF_K_FORWARD
)
1487 kind
= dtd
->dtd_data
.ctt_type
;
1489 if (dtd
->dtd_data
.ctt_name
1490 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1491 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1493 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
1495 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1498 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1499 ctf_dtd_delete (fp
, dtd
);
1502 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1504 nvd
= ctf_list_next (dvd
);
1506 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
1509 ctf_dvd_delete (fp
, dvd
);
1512 fp
->ctf_typemax
= id
.dtd_id
;
1513 fp
->ctf_snapshots
= id
.snapshot_id
;
1515 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
1516 fp
->ctf_flags
&= ~LCTF_DIRTY
;
1522 ctf_add_generic (ctf_dict_t
*fp
, uint32_t flag
, const char *name
, int kind
,
1528 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
1529 return (ctf_set_errno (fp
, EINVAL
));
1531 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1532 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1534 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
1535 return (ctf_set_errno (fp
, ECTF_FULL
));
1537 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
1538 return (ctf_set_errno (fp
, ECTF_FULL
));
1540 /* Make sure ptrtab always grows to be big enough for all types. */
1541 if (ctf_grow_ptrtab (fp
) < 0)
1542 return CTF_ERR
; /* errno is set for us. */
1544 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
1545 return (ctf_set_errno (fp
, EAGAIN
));
1547 type
= ++fp
->ctf_typemax
;
1548 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
1550 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
1551 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1552 dtd
->dtd_type
= type
;
1554 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
1557 return (ctf_set_errno (fp
, EAGAIN
));
1560 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
1563 return CTF_ERR
; /* errno is set for us. */
1565 fp
->ctf_flags
|= LCTF_DIRTY
;
1571 /* When encoding integer sizes, we want to convert a byte count in the range
1572 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
1573 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
1589 ctf_add_encoded (ctf_dict_t
*fp
, uint32_t flag
,
1590 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
1596 return (ctf_set_errno (fp
, EINVAL
));
1598 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1599 return CTF_ERR
; /* errno is set for us. */
1601 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1602 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1604 dtd
->dtd_u
.dtu_enc
= *ep
;
1610 ctf_add_reftype (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
1614 ctf_dict_t
*tmp
= fp
;
1615 int child
= fp
->ctf_flags
& LCTF_CHILD
;
1617 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1618 return (ctf_set_errno (fp
, EINVAL
));
1620 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1621 return CTF_ERR
; /* errno is set for us. */
1623 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
1624 return CTF_ERR
; /* errno is set for us. */
1626 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1627 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1629 if (kind
!= CTF_K_POINTER
)
1632 /* If we are adding a pointer, update the ptrtab, pointing at this type from
1633 the type it points to. Note that ctf_typemax is at this point one higher
1634 than we want to check against, because it's just been incremented for the
1635 addition of this type. The pptrtab is lazily-updated as needed, so is not
1638 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
1639 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
1641 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
1642 && ref_idx
< fp
->ctf_typemax
)
1643 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
1649 ctf_add_slice (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
,
1650 const ctf_encoding_t
*ep
)
1653 ctf_id_t resolved_ref
= ref
;
1656 const ctf_type_t
*tp
;
1657 ctf_dict_t
*tmp
= fp
;
1660 return (ctf_set_errno (fp
, EINVAL
));
1662 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
1663 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
1665 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1666 return (ctf_set_errno (fp
, EINVAL
));
1668 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
1669 return CTF_ERR
; /* errno is set for us. */
1671 /* Make sure we ultimately point to an integral type. We also allow slices to
1672 point to the unimplemented type, for now, because the compiler can emit
1673 such slices, though they're not very much use. */
1675 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
1676 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
1678 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
1679 (kind
!= CTF_K_ENUM
)
1681 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1683 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
1684 return CTF_ERR
; /* errno is set for us. */
1686 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
1687 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1689 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
1690 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
1691 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
1697 ctf_add_integer (ctf_dict_t
*fp
, uint32_t flag
,
1698 const char *name
, const ctf_encoding_t
*ep
)
1700 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1704 ctf_add_float (ctf_dict_t
*fp
, uint32_t flag
,
1705 const char *name
, const ctf_encoding_t
*ep
)
1707 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1711 ctf_add_pointer (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1713 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1717 ctf_add_array (ctf_dict_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1721 ctf_dict_t
*tmp
= fp
;
1724 return (ctf_set_errno (fp
, EINVAL
));
1726 if (arp
->ctr_contents
!= 0
1727 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1728 return CTF_ERR
; /* errno is set for us. */
1731 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1732 return CTF_ERR
; /* errno is set for us. */
1734 if (ctf_type_kind (fp
, arp
->ctr_index
) == CTF_K_FORWARD
)
1736 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
1737 _("ctf_add_array: index type %lx is incomplete"),
1739 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
1742 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1743 return CTF_ERR
; /* errno is set for us. */
1745 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1746 dtd
->dtd_data
.ctt_size
= 0;
1747 dtd
->dtd_u
.dtu_arr
= *arp
;
1753 ctf_set_array (ctf_dict_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1755 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1757 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1758 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1761 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1762 return (ctf_set_errno (fp
, ECTF_BADID
));
1764 fp
->ctf_flags
|= LCTF_DIRTY
;
1765 dtd
->dtd_u
.dtu_arr
= *arp
;
1771 ctf_add_function (ctf_dict_t
*fp
, uint32_t flag
,
1772 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1777 uint32_t *vdat
= NULL
;
1778 ctf_dict_t
*tmp
= fp
;
1781 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1782 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1784 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1785 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1786 return (ctf_set_errno (fp
, EINVAL
));
1788 vlen
= ctc
->ctc_argc
;
1789 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1790 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1792 if (ctc
->ctc_return
!= 0
1793 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1794 return CTF_ERR
; /* errno is set for us. */
1796 if (vlen
> CTF_MAX_VLEN
)
1797 return (ctf_set_errno (fp
, EOVERFLOW
));
1799 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1800 return (ctf_set_errno (fp
, EAGAIN
));
1802 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1805 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1808 return CTF_ERR
; /* errno is set for us. */
1810 vdat
[i
] = (uint32_t) argv
[i
];
1813 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1817 return CTF_ERR
; /* errno is set for us. */
1820 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1821 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1823 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1824 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1825 dtd
->dtd_u
.dtu_argv
= vdat
;
1831 ctf_add_struct_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1837 /* Promote root-visible forwards to structs. */
1839 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1841 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1842 dtd
= ctf_dtd_lookup (fp
, type
);
1843 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1845 return CTF_ERR
; /* errno is set for us. */
1847 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1849 if (size
> CTF_MAX_SIZE
)
1851 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1852 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1853 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1856 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1862 ctf_add_struct (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1864 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1868 ctf_add_union_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1874 /* Promote root-visible forwards to unions. */
1876 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1878 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1879 dtd
= ctf_dtd_lookup (fp
, type
);
1880 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1882 return CTF_ERR
; /* errno is set for us */
1884 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1886 if (size
> CTF_MAX_SIZE
)
1888 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1889 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1890 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1893 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1899 ctf_add_union (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1901 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1905 ctf_add_enum (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1910 /* Promote root-visible forwards to enums. */
1912 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1914 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1915 dtd
= ctf_dtd_lookup (fp
, type
);
1916 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1918 return CTF_ERR
; /* errno is set for us. */
1920 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1921 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1927 ctf_add_enum_encoded (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1928 const ctf_encoding_t
*ep
)
1932 /* First, create the enum if need be, using most of the same machinery as
1933 ctf_add_enum(), to ensure that we do not allow things past that are not
1934 enums or forwards to them. (This includes other slices: you cannot slice a
1935 slice, which would be a useless thing to do anyway.) */
1938 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1942 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1943 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1944 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1946 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1947 return CTF_ERR
; /* errno is set for us. */
1949 /* Now attach a suitable slice to it. */
1951 return ctf_add_slice (fp
, flag
, type
, ep
);
1955 ctf_add_forward (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1961 if (!ctf_forwardable_kind (kind
))
1962 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1964 /* If the type is already defined or exists as a forward tag, just
1965 return the ctf_id_t of the existing definition. */
1968 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1973 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1974 return CTF_ERR
; /* errno is set for us. */
1976 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1977 dtd
->dtd_data
.ctt_type
= kind
;
1983 ctf_add_typedef (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1988 ctf_dict_t
*tmp
= fp
;
1990 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1991 return (ctf_set_errno (fp
, EINVAL
));
1993 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1994 return CTF_ERR
; /* errno is set for us. */
1996 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1998 return CTF_ERR
; /* errno is set for us. */
2000 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
2001 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
2007 ctf_add_volatile (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2009 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
2013 ctf_add_const (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2015 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
2019 ctf_add_restrict (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
2021 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
2025 ctf_add_enumerator (ctf_dict_t
*fp
, ctf_id_t enid
, const char *name
,
2028 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
2031 uint32_t kind
, vlen
, root
;
2035 return (ctf_set_errno (fp
, EINVAL
));
2037 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2038 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2041 return (ctf_set_errno (fp
, ECTF_BADID
));
2043 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2044 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2045 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2047 if (kind
!= CTF_K_ENUM
)
2048 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
2050 if (vlen
== CTF_MAX_VLEN
)
2051 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2053 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2054 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2056 if (strcmp (dmd
->dmd_name
, name
) == 0)
2057 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2060 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2061 return (ctf_set_errno (fp
, EAGAIN
));
2063 if ((s
= strdup (name
)) == NULL
)
2066 return (ctf_set_errno (fp
, EAGAIN
));
2070 dmd
->dmd_type
= CTF_ERR
;
2071 dmd
->dmd_offset
= 0;
2072 dmd
->dmd_value
= value
;
2074 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2075 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2077 fp
->ctf_flags
|= LCTF_DIRTY
;
2083 ctf_add_member_offset (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2084 ctf_id_t type
, unsigned long bit_offset
)
2086 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
2089 ssize_t msize
, malign
, ssize
;
2090 uint32_t kind
, vlen
, root
;
2092 int is_incomplete
= 0;
2094 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2095 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2098 return (ctf_set_errno (fp
, ECTF_BADID
));
2100 if (name
!= NULL
&& name
[0] == '\0')
2103 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2104 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2105 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2107 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
2108 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
2110 if (vlen
== CTF_MAX_VLEN
)
2111 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2115 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2116 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2118 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
2119 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2123 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
2124 (malign
= ctf_type_align (fp
, type
)) < 0)
2126 /* The unimplemented type, and any type that resolves to it, has no size
2127 and no alignment: it can correspond to any number of compiler-inserted
2128 types. We allow incomplete types through since they are routinely
2129 added to the ends of structures, and can even be added elsewhere in
2130 structures by the deduplicator. They are assumed to be zero-size with
2131 no alignment: this is often wrong, but problems can be avoided in this
2132 case by explicitly specifying the size of the structure via the _sized
2133 functions. The deduplicator always does this. */
2137 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
2138 ctf_set_errno (fp
, 0);
2139 else if (ctf_errno (fp
) == ECTF_INCOMPLETE
)
2142 return -1; /* errno is set for us. */
2145 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2146 return (ctf_set_errno (fp
, EAGAIN
));
2148 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2151 return (ctf_set_errno (fp
, EAGAIN
));
2155 dmd
->dmd_type
= type
;
2156 dmd
->dmd_value
= -1;
2158 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
2160 if (bit_offset
== (unsigned long) - 1)
2162 /* Natural alignment. */
2164 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
2165 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
2166 size_t off
= lmd
->dmd_offset
;
2168 ctf_encoding_t linfo
;
2171 /* Propagate any error from ctf_type_resolve. If the last member was
2172 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
2173 cannot insert right after such a member without explicit offset
2174 specification, because its alignment and size is not known. */
2175 if (ltype
== CTF_ERR
)
2178 return -1; /* errno is set for us. */
2183 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2184 _("ctf_add_member_offset: cannot add member %s of "
2185 "incomplete type %lx to struct %lx without "
2186 "specifying explicit offset\n"),
2187 name
? name
: _("(unnamed member)"), type
, souid
);
2188 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
2191 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
2192 off
+= linfo
.cte_bits
;
2193 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
2194 off
+= lsize
* CHAR_BIT
;
2195 else if (lsize
== -1 && ctf_errno (fp
) == ECTF_INCOMPLETE
)
2197 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2198 _("ctf_add_member_offset: cannot add member %s of "
2199 "type %lx to struct %lx without specifying "
2200 "explicit offset after member %s of type %lx, "
2201 "which is an incomplete type\n"),
2202 name
? name
: _("(unnamed member)"), type
, souid
,
2203 lmd
->dmd_name
? lmd
->dmd_name
2204 : _("(unnamed member)"), ltype
);
2205 return -1; /* errno is set for us. */
2208 /* Round up the offset of the end of the last member to
2209 the next byte boundary, convert 'off' to bytes, and
2210 then round it up again to the next multiple of the
2211 alignment required by the new member. Finally,
2212 convert back to bits and store the result in
2213 dmd_offset. Technically we could do more efficient
2214 packing if the new member is a bit-field, but we're
2215 the "compiler" and ANSI says we can do as we choose. */
2217 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
2218 off
= roundup (off
, MAX (malign
, 1));
2219 dmd
->dmd_offset
= off
* CHAR_BIT
;
2220 ssize
= off
+ msize
;
2224 /* Specified offset in bits. */
2226 dmd
->dmd_offset
= bit_offset
;
2227 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2228 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
2233 dmd
->dmd_offset
= 0;
2234 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2235 ssize
= MAX (ssize
, msize
);
2238 if ((size_t) ssize
> CTF_MAX_SIZE
)
2240 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2241 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
2242 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
2245 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
2247 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2248 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2250 fp
->ctf_flags
|= LCTF_DIRTY
;
2255 ctf_add_member_encoded (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2256 ctf_id_t type
, unsigned long bit_offset
,
2257 const ctf_encoding_t encoding
)
2259 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
2260 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2263 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
2264 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
2266 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
2267 return -1; /* errno is set for us. */
2269 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
2273 ctf_add_member (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2276 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
2280 ctf_add_variable (ctf_dict_t
*fp
, const char *name
, ctf_id_t ref
)
2283 ctf_dict_t
*tmp
= fp
;
2285 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2286 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2288 if (ctf_dvd_lookup (fp
, name
) != NULL
)
2289 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2291 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
2292 return -1; /* errno is set for us. */
2294 /* Make sure this type is representable. */
2295 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
2296 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
2299 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
2300 return (ctf_set_errno (fp
, EAGAIN
));
2302 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
2305 return (ctf_set_errno (fp
, EAGAIN
));
2307 dvd
->dvd_type
= ref
;
2308 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
2310 if (ctf_dvd_insert (fp
, dvd
) < 0)
2312 free (dvd
->dvd_name
);
2314 return -1; /* errno is set for us. */
2317 fp
->ctf_flags
|= LCTF_DIRTY
;
2322 ctf_add_funcobjt_sym (ctf_dict_t
*fp
, int is_function
, const char *name
, ctf_id_t id
)
2324 ctf_dict_t
*tmp
= fp
;
2326 ctf_dynhash_t
*h
= is_function
? fp
->ctf_funchash
: fp
->ctf_objthash
;
2328 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2329 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2331 if (ctf_dynhash_lookup (fp
->ctf_objthash
, name
) != NULL
||
2332 ctf_dynhash_lookup (fp
->ctf_funchash
, name
) != NULL
)
2333 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2335 if (ctf_lookup_by_id (&tmp
, id
) == NULL
)
2336 return -1; /* errno is set for us. */
2338 if (is_function
&& ctf_type_kind (fp
, id
) != CTF_K_FUNCTION
)
2339 return (ctf_set_errno (fp
, ECTF_NOTFUNC
));
2341 if ((dupname
= strdup (name
)) == NULL
)
2342 return (ctf_set_errno (fp
, ENOMEM
));
2344 if (ctf_dynhash_insert (h
, dupname
, (void *) (uintptr_t) id
) < 0)
2347 return (ctf_set_errno (fp
, ENOMEM
));
2353 ctf_add_objt_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2355 return (ctf_add_funcobjt_sym (fp
, 0, name
, id
));
2359 ctf_add_func_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2361 return (ctf_add_funcobjt_sym (fp
, 1, name
, id
));
2364 typedef struct ctf_bundle
2366 ctf_dict_t
*ctb_dict
; /* CTF dict handle. */
2367 ctf_id_t ctb_type
; /* CTF type identifier. */
2368 ctf_dtdef_t
*ctb_dtd
; /* CTF dynamic type definition (if any). */
2372 enumcmp (const char *name
, int value
, void *arg
)
2374 ctf_bundle_t
*ctb
= arg
;
2377 if (ctf_enum_value (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &bvalue
) < 0)
2379 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2380 _("conflict due to enum %s iteration error"), name
);
2383 if (value
!= bvalue
)
2385 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2386 _("conflict due to enum value change: %i versus %i"),
2394 enumadd (const char *name
, int value
, void *arg
)
2396 ctf_bundle_t
*ctb
= arg
;
2398 return (ctf_add_enumerator (ctb
->ctb_dict
, ctb
->ctb_type
,
2403 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
2406 ctf_bundle_t
*ctb
= arg
;
2409 /* Don't check nameless members (e.g. anonymous structs/unions) against each
2414 if (ctf_member_info (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &ctm
) < 0)
2416 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2417 _("conflict due to struct member %s iteration error"),
2421 if (ctm
.ctm_offset
!= offset
)
2423 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2424 _("conflict due to struct member %s offset change: "
2426 name
, ctm
.ctm_offset
, offset
);
2433 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
2435 ctf_bundle_t
*ctb
= arg
;
2439 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2440 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2442 /* Unnamed members in non-dynamic dicts have a name of "", while dynamic dicts
2448 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2451 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2454 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
2455 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
2457 dmd
->dmd_type
= type
;
2458 dmd
->dmd_offset
= offset
;
2459 dmd
->dmd_value
= -1;
2461 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
2463 ctb
->ctb_dict
->ctf_flags
|= LCTF_DIRTY
;
2467 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
2468 to a dynamic destination dictionary. This routine operates recursively by
2469 following the source type's links and embedded member types. If the
2470 destination dict already contains a named type which has the same attributes,
2471 then we succeed and return this type but no changes occur. */
2473 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2474 ctf_dict_t
*proc_tracking_fp
)
2476 ctf_id_t dst_type
= CTF_ERR
;
2477 uint32_t dst_kind
= CTF_K_UNKNOWN
;
2478 ctf_dict_t
*tmp_fp
= dst_fp
;
2482 uint32_t kind
, forward_kind
, flag
, vlen
;
2484 const ctf_type_t
*src_tp
, *dst_tp
;
2485 ctf_bundle_t src
, dst
;
2486 ctf_encoding_t src_en
, dst_en
;
2487 ctf_arinfo_t src_ar
, dst_ar
;
2491 ctf_id_t orig_src_type
= src_type
;
2493 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
2494 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
2496 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
2497 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2499 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
2500 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
2501 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
2503 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
2504 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
2505 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
2506 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
2508 /* If this is a type we are currently in the middle of adding, hand it
2509 straight back. (This lets us handle self-referential structures without
2510 considering forwards and empty structures the same as their completed
2513 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
2517 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
2518 (void *) (uintptr_t) src_type
))
2521 /* If this type has already been added from this dictionary, and is the
2522 same kind and (if a struct or union) has the same number of members,
2523 hand it straight back. */
2525 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
2527 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
2528 || kind
== CTF_K_ENUM
)
2530 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
2531 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
2539 forward_kind
= kind
;
2540 if (kind
== CTF_K_FORWARD
)
2541 forward_kind
= src_tp
->ctt_type
;
2543 /* If the source type has a name and is a root type (visible at the top-level
2544 scope), lookup the name in the destination dictionary and verify that it is
2545 of the same kind before we do anything else. */
2547 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
2548 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
2551 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
2554 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
2555 unless dst_type is a forward declaration and src_type is a struct,
2556 union, or enum (i.e. the definition of the previous forward decl).
2558 We also allow addition in the opposite order (addition of a forward when a
2559 struct, union, or enum already exists), which is a NOP and returns the
2560 already-present struct, union, or enum. */
2562 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
2564 if (kind
== CTF_K_FORWARD
2565 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
2566 || dst_kind
== CTF_K_UNION
))
2568 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2572 if (dst_kind
!= CTF_K_FORWARD
2573 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
2574 && kind
!= CTF_K_UNION
))
2576 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2577 _("ctf_add_type: conflict for type %s: "
2578 "kinds differ, new: %i; old (ID %lx): %i"),
2579 name
, kind
, dst_type
, dst_kind
);
2580 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2584 /* We take special action for an integer, float, or slice since it is
2585 described not only by its name but also its encoding. For integers,
2586 bit-fields exploit this degeneracy. */
2588 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
2590 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
2591 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2593 if (dst_type
!= CTF_ERR
)
2595 ctf_dict_t
*fp
= dst_fp
;
2597 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
2600 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
2601 return CTF_ERR
; /* errno set for us. */
2603 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
2605 /* The type that we found in the hash is also root-visible. If
2606 the two types match then use the existing one; otherwise,
2607 declare a conflict. Note: slices are not certain to match
2608 even if there is no conflict: we must check the contained type
2611 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2613 if (kind
!= CTF_K_SLICE
)
2615 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2621 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2626 /* We found a non-root-visible type in the hash. If its encoding
2627 is the same, we can reuse it, unless it is a slice. */
2629 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2631 if (kind
!= CTF_K_SLICE
)
2633 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2641 src
.ctb_dict
= src_fp
;
2642 src
.ctb_type
= src_type
;
2645 dst
.ctb_dict
= dst_fp
;
2646 dst
.ctb_type
= dst_type
;
2649 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
2650 a new type with the same properties as src_type to dst_fp. If dst_type is
2651 not CTF_ERR, then we verify that dst_type has the same attributes as
2652 src_type. We recurse for embedded references. Before we start, we note
2653 that we are processing this type, to prevent infinite recursion: we do not
2654 re-process any type that appears in this list. The list is emptied
2655 wholesale at the end of processing everything in this recursive stack. */
2657 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
2658 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
2659 return ctf_set_errno (dst_fp
, ENOMEM
);
2664 /* If we found a match we will have either returned it or declared a
2666 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
2670 /* If we found a match we will have either returned it or declared a
2672 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
2676 /* We have checked for conflicting encodings: now try to add the
2678 src_type
= ctf_type_reference (src_fp
, src_type
);
2679 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2682 if (src_type
== CTF_ERR
)
2683 return CTF_ERR
; /* errno is set for us. */
2685 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
2689 case CTF_K_VOLATILE
:
2691 case CTF_K_RESTRICT
:
2692 src_type
= ctf_type_reference (src_fp
, src_type
);
2693 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2696 if (src_type
== CTF_ERR
)
2697 return CTF_ERR
; /* errno is set for us. */
2699 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
2703 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
2704 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2706 src_ar
.ctr_contents
=
2707 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
2709 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
2712 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
2714 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
2715 return CTF_ERR
; /* errno is set for us. */
2717 if (dst_type
!= CTF_ERR
)
2719 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
2720 return CTF_ERR
; /* errno is set for us. */
2722 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
2724 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2725 _("conflict for type %s against ID %lx: array info "
2726 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
2727 name
, dst_type
, src_ar
.ctr_contents
,
2728 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
2729 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
2731 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2735 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
2738 case CTF_K_FUNCTION
:
2739 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
2745 if (ctc
.ctc_return
== CTF_ERR
)
2746 return CTF_ERR
; /* errno is set for us. */
2748 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
2760 /* Technically to match a struct or union we need to check both
2761 ways (src members vs. dst, dst members vs. src) but we make
2762 this more optimal by only checking src vs. dst and comparing
2763 the total size of the structure (which we must do anyway)
2764 which covers the possibility of dst members not in src.
2765 This optimization can be defeated for unions, but is so
2766 pathological as to render it irrelevant for our purposes. */
2768 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2769 && dst_kind
!= CTF_K_FORWARD
)
2771 if (ctf_type_size (src_fp
, src_type
) !=
2772 ctf_type_size (dst_fp
, dst_type
))
2774 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2775 _("conflict for type %s against ID %lx: union "
2776 "size differs, old %li, new %li"), name
,
2777 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
2778 (long) ctf_type_size (dst_fp
, dst_type
));
2779 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2782 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
2784 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2785 _("conflict for type %s against ID %lx: members "
2786 "differ, see above"), name
, dst_type
);
2787 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2793 /* Unlike the other cases, copying structs and unions is done
2794 manually so as to avoid repeated lookups in ctf_add_member
2795 and to ensure the exact same member offsets as in src_type. */
2797 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2798 if (dst_type
== CTF_ERR
)
2799 return CTF_ERR
; /* errno is set for us. */
2801 dst
.ctb_type
= dst_type
;
2804 /* Pre-emptively add this struct to the type mapping so that
2805 structures that refer to themselves work. */
2806 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2808 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2809 errs
++; /* Increment errs and fail at bottom of case. */
2811 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2812 return CTF_ERR
; /* errno is set for us. */
2814 size
= (size_t) ssize
;
2815 if (size
> CTF_MAX_SIZE
)
2817 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2818 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2819 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2822 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2824 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2826 /* Make a final pass through the members changing each dmd_type (a
2827 src_fp type) to an equivalent type in dst_fp. We pass through all
2828 members, leaving any that fail set to CTF_ERR, unless they fail
2829 because they are marking a member of type not representable in this
2830 version of CTF, in which case we just want to silently omit them:
2831 no consumer can do anything with them anyway. */
2832 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2833 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2835 ctf_dict_t
*dst
= dst_fp
;
2838 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2841 if ((dmd
->dmd_type
=
2842 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2843 proc_tracking_fp
)) == CTF_ERR
)
2845 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2850 dmd
->dmd_type
= memb_type
;
2854 return CTF_ERR
; /* errno is set for us. */
2859 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2860 && dst_kind
!= CTF_K_FORWARD
)
2862 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2863 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2865 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2866 _("conflict for enum %s against ID %lx: members "
2867 "differ, see above"), name
, dst_type
);
2868 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2873 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2874 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2875 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2876 return CTF_ERR
; /* errno is set for us */
2881 if (dst_type
== CTF_ERR
)
2882 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2886 src_type
= ctf_type_reference (src_fp
, src_type
);
2887 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2890 if (src_type
== CTF_ERR
)
2891 return CTF_ERR
; /* errno is set for us. */
2893 /* If dst_type is not CTF_ERR at this point, we should check if
2894 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2895 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2896 that vary based on things like if 32-bit then pid_t is int otherwise
2897 long. We therefore omit this check and assume that if the identically
2898 named typedef already exists in dst_fp, it is correct or
2901 if (dst_type
== CTF_ERR
)
2902 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2907 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2910 if (dst_type
!= CTF_ERR
)
2911 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2916 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
2920 if (!src_fp
->ctf_add_processing
)
2921 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2922 ctf_hash_eq_integer
,
2925 /* We store the hash on the source, because it contains only source type IDs:
2926 but callers will invariably expect errors to appear on the dest. */
2927 if (!src_fp
->ctf_add_processing
)
2928 return (ctf_set_errno (dst_fp
, ENOMEM
));
2930 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2931 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2936 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2938 ctf_gzwrite (ctf_dict_t
*fp
, gzFile fd
)
2940 const unsigned char *buf
;
2944 resid
= sizeof (ctf_header_t
);
2945 buf
= (unsigned char *) fp
->ctf_header
;
2948 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2949 return (ctf_set_errno (fp
, errno
));
2954 resid
= fp
->ctf_size
;
2958 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2959 return (ctf_set_errno (fp
, errno
));
2967 /* Compress the specified CTF data stream and write it to the specified file
2970 ctf_compress_write (ctf_dict_t
*fp
, int fd
)
2975 ctf_header_t
*hp
= &h
;
2976 ssize_t header_len
= sizeof (ctf_header_t
);
2977 ssize_t compress_len
;
2982 if (ctf_serialize (fp
) < 0)
2983 return -1; /* errno is set for us. */
2985 memcpy (hp
, fp
->ctf_header
, header_len
);
2986 hp
->cth_flags
|= CTF_F_COMPRESS
;
2987 compress_len
= compressBound (fp
->ctf_size
);
2989 if ((buf
= malloc (compress_len
)) == NULL
)
2991 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
2992 (unsigned long) compress_len
);
2993 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2996 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2997 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2999 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
3000 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3004 while (header_len
> 0)
3006 if ((len
= write (fd
, hp
, header_len
)) < 0)
3008 err
= ctf_set_errno (fp
, errno
);
3009 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing header"));
3017 while (compress_len
> 0)
3019 if ((len
= write (fd
, bp
, compress_len
)) < 0)
3021 err
= ctf_set_errno (fp
, errno
);
3022 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing"));
3025 compress_len
-= len
;
3034 /* Optionally compress the specified CTF data stream and return it as a new
3035 dynamically-allocated string. */
3037 ctf_write_mem (ctf_dict_t
*fp
, size_t *size
, size_t threshold
)
3042 ssize_t header_len
= sizeof (ctf_header_t
);
3043 ssize_t compress_len
;
3046 if (ctf_serialize (fp
) < 0)
3047 return NULL
; /* errno is set for us. */
3049 compress_len
= compressBound (fp
->ctf_size
);
3050 if (fp
->ctf_size
< threshold
)
3051 compress_len
= fp
->ctf_size
;
3052 if ((buf
= malloc (compress_len
3053 + sizeof (struct ctf_header
))) == NULL
)
3055 ctf_set_errno (fp
, ENOMEM
);
3056 ctf_err_warn (fp
, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
3057 (unsigned long) (compress_len
+ sizeof (struct ctf_header
)));
3061 hp
= (ctf_header_t
*) buf
;
3062 memcpy (hp
, fp
->ctf_header
, header_len
);
3063 bp
= buf
+ sizeof (struct ctf_header
);
3064 *size
= sizeof (struct ctf_header
);
3066 if (fp
->ctf_size
< threshold
)
3068 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
3069 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
3070 *size
+= fp
->ctf_size
;
3074 hp
->cth_flags
|= CTF_F_COMPRESS
;
3075 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
3076 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3078 ctf_set_errno (fp
, ECTF_COMPRESS
);
3079 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3083 *size
+= compress_len
;
3088 /* Write the uncompressed CTF data stream to the specified file descriptor. */
3090 ctf_write (ctf_dict_t
*fp
, int fd
)
3092 const unsigned char *buf
;
3096 if (ctf_serialize (fp
) < 0)
3097 return -1; /* errno is set for us. */
3099 resid
= sizeof (ctf_header_t
);
3100 buf
= (unsigned char *) fp
->ctf_header
;
3103 if ((len
= write (fd
, buf
, resid
)) <= 0)
3105 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing header"));
3106 return (ctf_set_errno (fp
, errno
));
3112 resid
= fp
->ctf_size
;
3116 if ((len
= write (fd
, buf
, resid
)) <= 0)
3118 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing"));
3119 return (ctf_set_errno (fp
, errno
));