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 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
2475 to a dynamic destination dictionary. This routine operates recursively by
2476 following the source type's links and embedded member types. If the
2477 destination dict already contains a named type which has the same attributes,
2478 then we succeed and return this type but no changes occur. */
2480 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2481 ctf_dict_t
*proc_tracking_fp
)
2483 ctf_id_t dst_type
= CTF_ERR
;
2484 uint32_t dst_kind
= CTF_K_UNKNOWN
;
2485 ctf_dict_t
*tmp_fp
= dst_fp
;
2489 uint32_t kind
, forward_kind
, flag
, vlen
;
2491 const ctf_type_t
*src_tp
, *dst_tp
;
2492 ctf_bundle_t src
, dst
;
2493 ctf_encoding_t src_en
, dst_en
;
2494 ctf_arinfo_t src_ar
, dst_ar
;
2498 ctf_id_t orig_src_type
= src_type
;
2500 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
2501 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
2503 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
2504 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2506 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
2507 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
2508 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
2510 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
2511 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
2512 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
2513 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
2515 /* If this is a type we are currently in the middle of adding, hand it
2516 straight back. (This lets us handle self-referential structures without
2517 considering forwards and empty structures the same as their completed
2520 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
2524 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
2525 (void *) (uintptr_t) src_type
))
2528 /* If this type has already been added from this dictionary, and is the
2529 same kind and (if a struct or union) has the same number of members,
2530 hand it straight back. */
2532 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
2534 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
2535 || kind
== CTF_K_ENUM
)
2537 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
2538 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
2546 forward_kind
= kind
;
2547 if (kind
== CTF_K_FORWARD
)
2548 forward_kind
= src_tp
->ctt_type
;
2550 /* If the source type has a name and is a root type (visible at the top-level
2551 scope), lookup the name in the destination dictionary and verify that it is
2552 of the same kind before we do anything else. */
2554 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
2555 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
2558 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
2561 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
2562 unless dst_type is a forward declaration and src_type is a struct,
2563 union, or enum (i.e. the definition of the previous forward decl).
2565 We also allow addition in the opposite order (addition of a forward when a
2566 struct, union, or enum already exists), which is a NOP and returns the
2567 already-present struct, union, or enum. */
2569 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
2571 if (kind
== CTF_K_FORWARD
2572 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
2573 || dst_kind
== CTF_K_UNION
))
2575 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2579 if (dst_kind
!= CTF_K_FORWARD
2580 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
2581 && kind
!= CTF_K_UNION
))
2583 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2584 _("ctf_add_type: conflict for type %s: "
2585 "kinds differ, new: %i; old (ID %lx): %i"),
2586 name
, kind
, dst_type
, dst_kind
);
2587 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2591 /* We take special action for an integer, float, or slice since it is
2592 described not only by its name but also its encoding. For integers,
2593 bit-fields exploit this degeneracy. */
2595 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
2597 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
2598 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2600 if (dst_type
!= CTF_ERR
)
2602 ctf_dict_t
*fp
= dst_fp
;
2604 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
2607 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
2608 return CTF_ERR
; /* errno set for us. */
2610 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
2612 /* The type that we found in the hash is also root-visible. If
2613 the two types match then use the existing one; otherwise,
2614 declare a conflict. Note: slices are not certain to match
2615 even if there is no conflict: we must check the contained type
2618 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2620 if (kind
!= CTF_K_SLICE
)
2622 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2628 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2633 /* We found a non-root-visible type in the hash. If its encoding
2634 is the same, we can reuse it, unless it is a slice. */
2636 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2638 if (kind
!= CTF_K_SLICE
)
2640 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2648 src
.ctb_dict
= src_fp
;
2649 src
.ctb_type
= src_type
;
2652 dst
.ctb_dict
= dst_fp
;
2653 dst
.ctb_type
= dst_type
;
2656 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
2657 a new type with the same properties as src_type to dst_fp. If dst_type is
2658 not CTF_ERR, then we verify that dst_type has the same attributes as
2659 src_type. We recurse for embedded references. Before we start, we note
2660 that we are processing this type, to prevent infinite recursion: we do not
2661 re-process any type that appears in this list. The list is emptied
2662 wholesale at the end of processing everything in this recursive stack. */
2664 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
2665 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
2666 return ctf_set_errno (dst_fp
, ENOMEM
);
2671 /* If we found a match we will have either returned it or declared a
2673 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
2677 /* If we found a match we will have either returned it or declared a
2679 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
2683 /* We have checked for conflicting encodings: now try to add the
2685 src_type
= ctf_type_reference (src_fp
, src_type
);
2686 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2689 if (src_type
== CTF_ERR
)
2690 return CTF_ERR
; /* errno is set for us. */
2692 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
2696 case CTF_K_VOLATILE
:
2698 case CTF_K_RESTRICT
:
2699 src_type
= ctf_type_reference (src_fp
, src_type
);
2700 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2703 if (src_type
== CTF_ERR
)
2704 return CTF_ERR
; /* errno is set for us. */
2706 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
2710 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
2711 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2713 src_ar
.ctr_contents
=
2714 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
2716 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
2719 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
2721 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
2722 return CTF_ERR
; /* errno is set for us. */
2724 if (dst_type
!= CTF_ERR
)
2726 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
2727 return CTF_ERR
; /* errno is set for us. */
2729 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
2731 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2732 _("conflict for type %s against ID %lx: array info "
2733 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
2734 name
, dst_type
, src_ar
.ctr_contents
,
2735 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
2736 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
2738 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2742 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
2745 case CTF_K_FUNCTION
:
2746 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
2752 if (ctc
.ctc_return
== CTF_ERR
)
2753 return CTF_ERR
; /* errno is set for us. */
2755 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
2767 /* Technically to match a struct or union we need to check both
2768 ways (src members vs. dst, dst members vs. src) but we make
2769 this more optimal by only checking src vs. dst and comparing
2770 the total size of the structure (which we must do anyway)
2771 which covers the possibility of dst members not in src.
2772 This optimization can be defeated for unions, but is so
2773 pathological as to render it irrelevant for our purposes. */
2775 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2776 && dst_kind
!= CTF_K_FORWARD
)
2778 if (ctf_type_size (src_fp
, src_type
) !=
2779 ctf_type_size (dst_fp
, dst_type
))
2781 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2782 _("conflict for type %s against ID %lx: union "
2783 "size differs, old %li, new %li"), name
,
2784 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
2785 (long) ctf_type_size (dst_fp
, dst_type
));
2786 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2789 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
2791 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2792 _("conflict for type %s against ID %lx: members "
2793 "differ, see above"), name
, dst_type
);
2794 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2800 /* Unlike the other cases, copying structs and unions is done
2801 manually so as to avoid repeated lookups in ctf_add_member
2802 and to ensure the exact same member offsets as in src_type. */
2804 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2805 if (dst_type
== CTF_ERR
)
2806 return CTF_ERR
; /* errno is set for us. */
2808 dst
.ctb_type
= dst_type
;
2811 /* Pre-emptively add this struct to the type mapping so that
2812 structures that refer to themselves work. */
2813 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2815 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2816 errs
++; /* Increment errs and fail at bottom of case. */
2818 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2819 return CTF_ERR
; /* errno is set for us. */
2821 size
= (size_t) ssize
;
2822 if (size
> CTF_MAX_SIZE
)
2824 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2825 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2826 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2829 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2831 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2833 /* Make a final pass through the members changing each dmd_type (a
2834 src_fp type) to an equivalent type in dst_fp. We pass through all
2835 members, leaving any that fail set to CTF_ERR, unless they fail
2836 because they are marking a member of type not representable in this
2837 version of CTF, in which case we just want to silently omit them:
2838 no consumer can do anything with them anyway. */
2839 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2840 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2842 ctf_dict_t
*dst
= dst_fp
;
2845 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2848 if ((dmd
->dmd_type
=
2849 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2850 proc_tracking_fp
)) == CTF_ERR
)
2852 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2857 dmd
->dmd_type
= memb_type
;
2861 return CTF_ERR
; /* errno is set for us. */
2866 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2867 && dst_kind
!= CTF_K_FORWARD
)
2869 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2870 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2872 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2873 _("conflict for enum %s against ID %lx: members "
2874 "differ, see above"), name
, dst_type
);
2875 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2880 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2881 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2882 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2883 return CTF_ERR
; /* errno is set for us */
2888 if (dst_type
== CTF_ERR
)
2889 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2893 src_type
= ctf_type_reference (src_fp
, src_type
);
2894 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2897 if (src_type
== CTF_ERR
)
2898 return CTF_ERR
; /* errno is set for us. */
2900 /* If dst_type is not CTF_ERR at this point, we should check if
2901 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2902 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2903 that vary based on things like if 32-bit then pid_t is int otherwise
2904 long. We therefore omit this check and assume that if the identically
2905 named typedef already exists in dst_fp, it is correct or
2908 if (dst_type
== CTF_ERR
)
2909 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2914 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2917 if (dst_type
!= CTF_ERR
)
2918 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2923 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
2927 if (!src_fp
->ctf_add_processing
)
2928 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2929 ctf_hash_eq_integer
,
2932 /* We store the hash on the source, because it contains only source type IDs:
2933 but callers will invariably expect errors to appear on the dest. */
2934 if (!src_fp
->ctf_add_processing
)
2935 return (ctf_set_errno (dst_fp
, ENOMEM
));
2937 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2938 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2943 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2945 ctf_gzwrite (ctf_dict_t
*fp
, gzFile fd
)
2947 const unsigned char *buf
;
2951 resid
= sizeof (ctf_header_t
);
2952 buf
= (unsigned char *) fp
->ctf_header
;
2955 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2956 return (ctf_set_errno (fp
, errno
));
2961 resid
= fp
->ctf_size
;
2965 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2966 return (ctf_set_errno (fp
, errno
));
2974 /* Compress the specified CTF data stream and write it to the specified file
2977 ctf_compress_write (ctf_dict_t
*fp
, int fd
)
2982 ctf_header_t
*hp
= &h
;
2983 ssize_t header_len
= sizeof (ctf_header_t
);
2984 ssize_t compress_len
;
2989 if (ctf_serialize (fp
) < 0)
2990 return -1; /* errno is set for us. */
2992 memcpy (hp
, fp
->ctf_header
, header_len
);
2993 hp
->cth_flags
|= CTF_F_COMPRESS
;
2994 compress_len
= compressBound (fp
->ctf_size
);
2996 if ((buf
= malloc (compress_len
)) == NULL
)
2998 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
2999 (unsigned long) compress_len
);
3000 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
3003 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
3004 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3006 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
3007 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3011 while (header_len
> 0)
3013 if ((len
= write (fd
, hp
, header_len
)) < 0)
3015 err
= ctf_set_errno (fp
, errno
);
3016 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing header"));
3024 while (compress_len
> 0)
3026 if ((len
= write (fd
, bp
, compress_len
)) < 0)
3028 err
= ctf_set_errno (fp
, errno
);
3029 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing"));
3032 compress_len
-= len
;
3041 /* Optionally compress the specified CTF data stream and return it as a new
3042 dynamically-allocated string. */
3044 ctf_write_mem (ctf_dict_t
*fp
, size_t *size
, size_t threshold
)
3049 ssize_t header_len
= sizeof (ctf_header_t
);
3050 ssize_t compress_len
;
3053 if (ctf_serialize (fp
) < 0)
3054 return NULL
; /* errno is set for us. */
3056 compress_len
= compressBound (fp
->ctf_size
);
3057 if (fp
->ctf_size
< threshold
)
3058 compress_len
= fp
->ctf_size
;
3059 if ((buf
= malloc (compress_len
3060 + sizeof (struct ctf_header
))) == NULL
)
3062 ctf_set_errno (fp
, ENOMEM
);
3063 ctf_err_warn (fp
, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
3064 (unsigned long) (compress_len
+ sizeof (struct ctf_header
)));
3068 hp
= (ctf_header_t
*) buf
;
3069 memcpy (hp
, fp
->ctf_header
, header_len
);
3070 bp
= buf
+ sizeof (struct ctf_header
);
3071 *size
= sizeof (struct ctf_header
);
3073 if (fp
->ctf_size
< threshold
)
3075 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
3076 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
3077 *size
+= fp
->ctf_size
;
3081 hp
->cth_flags
|= CTF_F_COMPRESS
;
3082 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
3083 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3085 ctf_set_errno (fp
, ECTF_COMPRESS
);
3086 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3090 *size
+= compress_len
;
3095 /* Write the uncompressed CTF data stream to the specified file descriptor. */
3097 ctf_write (ctf_dict_t
*fp
, int fd
)
3099 const unsigned char *buf
;
3103 if (ctf_serialize (fp
) < 0)
3104 return -1; /* errno is set for us. */
3106 resid
= sizeof (ctf_header_t
);
3107 buf
= (unsigned char *) fp
->ctf_header
;
3110 if ((len
= write (fd
, buf
, resid
)) <= 0)
3112 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing header"));
3113 return (ctf_set_errno (fp
, errno
));
3119 resid
= fp
->ctf_size
;
3123 if ((len
= write (fd
, buf
, resid
)) <= 0)
3125 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing"));
3126 return (ctf_set_errno (fp
, errno
));