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
)
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 && type
== dvd
->dvd_type
)
187 ctf_dvd_delete (fp
, dvd
);
193 /* Determine if a symbol is "skippable" and should never appear in the
194 symtypetab sections. */
197 ctf_symtab_skippable (ctf_link_sym_t
*sym
)
199 /* Never skip symbols whose name is not yet known. */
200 if (sym
->st_nameidx_set
)
203 return (sym
->st_name
== NULL
|| sym
->st_name
[0] == 0
204 || sym
->st_shndx
== SHN_UNDEF
205 || strcmp (sym
->st_name
, "_START_") == 0
206 || strcmp (sym
->st_name
, "_END_") == 0
207 || (sym
->st_type
== STT_OBJECT
&& sym
->st_shndx
== SHN_EXTABS
208 && sym
->st_value
== 0));
211 /* Symtypetab emission flags. */
213 #define CTF_SYMTYPETAB_EMIT_FUNCTION 0x1
214 #define CTF_SYMTYPETAB_EMIT_PAD 0x2
215 #define CTF_SYMTYPETAB_FORCE_INDEXED 0x4
217 /* Get the number of symbols in a symbol hash, the count of symbols, the maximum
218 seen, the eventual size, without any padding elements, of the func/data and
219 (if generated) index sections, and the size of accumulated padding elements.
220 The linker-reported set of symbols is found in SYMFP.
222 Also figure out if any symbols need to be moved to the variable section, and
223 add them (if not already present). */
227 symtypetab_density (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, ctf_dynhash_t
*symhash
,
228 size_t *count
, size_t *max
, size_t *unpadsize
,
229 size_t *padsize
, size_t *idxsize
, int flags
)
231 ctf_next_t
*i
= NULL
;
234 ctf_dynhash_t
*linker_known
= NULL
;
244 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
246 /* Make a dynhash citing only symbols reported by the linker of the
247 appropriate type, then traverse all potential-symbols we know the types
248 of, removing them from linker_known as we go. Once this is done, the
249 only symbols remaining in linker_known are symbols we don't know the
250 types of: we must emit pads for those symbols that are below the
251 maximum symbol we will emit (any beyond that are simply skipped). */
253 if ((linker_known
= ctf_dynhash_create (ctf_hash_string
, ctf_hash_eq_string
,
254 NULL
, NULL
)) == NULL
)
255 return (ctf_set_errno (fp
, ENOMEM
));
257 while ((err
= ctf_dynhash_cnext (symfp
->ctf_dynsyms
, &i
,
258 &name
, &ctf_sym
)) == 0)
260 ctf_link_sym_t
*sym
= (ctf_link_sym_t
*) ctf_sym
;
262 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
263 && sym
->st_type
!= STT_FUNC
)
264 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
265 && sym
->st_type
!= STT_OBJECT
))
268 if (ctf_symtab_skippable (sym
))
271 /* This should only be true briefly before all the names are
272 finalized, long before we get this far. */
273 if (!ctf_assert (fp
, !sym
->st_nameidx_set
))
274 return -1; /* errno is set for us. */
276 if (ctf_dynhash_cinsert (linker_known
, name
, ctf_sym
) < 0)
278 ctf_dynhash_destroy (linker_known
);
279 return (ctf_set_errno (fp
, ENOMEM
));
282 if (err
!= ECTF_NEXT_END
)
284 ctf_err_warn (fp
, 0, err
, _("iterating over linker-known symbols during "
286 ctf_dynhash_destroy (linker_known
);
287 return (ctf_set_errno (fp
, err
));
291 while ((err
= ctf_dynhash_cnext (symhash
, &i
, &name
, NULL
)) == 0)
295 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
297 /* Linker did not report symbol in symtab. Remove it from the
298 set of known data symbols and continue. */
299 if ((sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, name
)) == NULL
)
301 ctf_dynhash_remove (symhash
, name
);
305 /* We don't remove skippable symbols from the symhash because we don't
306 want them to be migrated into variables. */
307 if (ctf_symtab_skippable (sym
))
310 if ((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
311 && sym
->st_type
!= STT_FUNC
)
313 ctf_err_warn (fp
, 1, 0, _("Symbol %x added to CTF as a function "
314 "but is of type %x\n"),
315 sym
->st_symidx
, sym
->st_type
);
316 ctf_dynhash_remove (symhash
, name
);
319 else if (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
320 && sym
->st_type
!= STT_OBJECT
)
322 ctf_err_warn (fp
, 1, 0, _("Symbol %x added to CTF as a data "
323 "object but is of type %x\n"),
324 sym
->st_symidx
, sym
->st_type
);
325 ctf_dynhash_remove (symhash
, name
);
329 ctf_dynhash_remove (linker_known
, name
);
331 *unpadsize
+= sizeof (uint32_t);
334 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
336 if (*max
< sym
->st_symidx
)
337 *max
= sym
->st_symidx
;
342 if (err
!= ECTF_NEXT_END
)
344 ctf_err_warn (fp
, 0, err
, _("iterating over CTF symtypetab during "
346 ctf_dynhash_destroy (linker_known
);
347 return (ctf_set_errno (fp
, err
));
350 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
352 while ((err
= ctf_dynhash_cnext (linker_known
, &i
, NULL
, &ctf_sym
)) == 0)
354 ctf_link_sym_t
*sym
= (ctf_link_sym_t
*) ctf_sym
;
356 if (sym
->st_symidx
> *max
)
359 if (err
!= ECTF_NEXT_END
)
361 ctf_err_warn (fp
, 0, err
, _("iterating over linker-known symbols "
362 "during CTF serialization"));
363 ctf_dynhash_destroy (linker_known
);
364 return (ctf_set_errno (fp
, err
));
368 *idxsize
= *count
* sizeof (uint32_t);
369 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
370 *padsize
= (ctf_dynhash_elements (linker_known
) - beyond_max
) * sizeof (uint32_t);
372 ctf_dynhash_destroy (linker_known
);
376 /* Emit an objt or func symtypetab into DP in a particular order defined by an
377 array of ctf_link_sym_t or symbol names passed in. The index has NIDX
378 elements in it: unindexed output would terminate at symbol OUTMAX and is in
379 any case no larger than SIZE bytes. Some index elements are expected to be
380 skipped: see symtypetab_density. The linker-reported set of symbols (if any)
381 is found in SYMFP. */
383 emit_symtypetab (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, uint32_t *dp
,
384 ctf_link_sym_t
**idx
, const char **nameidx
, uint32_t nidx
,
385 uint32_t outmax
, int size
, int flags
)
389 ctf_dynhash_t
*symhash
;
391 ctf_dprintf ("Emitting table of size %i, outmax %u, %u symtypetab entries, "
392 "flags %i\n", size
, outmax
, nidx
, flags
);
394 /* Empty table? Nothing to do. */
398 if (flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
399 symhash
= fp
->ctf_funchash
;
401 symhash
= fp
->ctf_objthash
;
403 for (i
= 0; i
< nidx
; i
++)
405 const char *sym_name
;
408 /* If we have a linker-reported set of symbols, we may be given that set
409 to work from, or a set of symbol names. In both cases we want to look
410 at the corresponding linker-reported symbol (if any). */
411 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
413 ctf_link_sym_t
*this_link_sym
;
416 this_link_sym
= idx
[i
];
418 this_link_sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, nameidx
[i
]);
420 /* Unreported symbol number. No pad, no nothing. */
424 /* Symbol of the wrong type, or skippable? This symbol is not in this
426 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
427 && this_link_sym
->st_type
!= STT_FUNC
)
428 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
429 && this_link_sym
->st_type
!= STT_OBJECT
))
432 if (ctf_symtab_skippable (this_link_sym
))
435 sym_name
= this_link_sym
->st_name
;
437 /* Linker reports symbol of a different type to the symbol we actually
438 added? Skip the symbol. No pad, since the symbol doesn't actually
439 belong in this table at all. (Warned about in
440 symtypetab_density.) */
441 if ((this_link_sym
->st_type
== STT_FUNC
)
442 && (ctf_dynhash_lookup (fp
->ctf_objthash
, sym_name
)))
445 if ((this_link_sym
->st_type
== STT_OBJECT
)
446 && (ctf_dynhash_lookup (fp
->ctf_funchash
, sym_name
)))
450 sym_name
= nameidx
[i
];
452 /* Symbol in index but no type set? Silently skip and (optionally)
453 pad. (In force-indexed mode, this is also where we track symbols of
454 the wrong type for this round of insertion.) */
455 if ((type
= ctf_dynhash_lookup (symhash
, sym_name
)) == NULL
)
457 if (flags
& CTF_SYMTYPETAB_EMIT_PAD
)
462 if (!ctf_assert (fp
, (((char *) dpp
) - (char *) dp
) < size
))
463 return -1; /* errno is set for us. */
465 *dpp
++ = (ctf_id_t
) (uintptr_t) type
;
467 /* When emitting unindexed output, all later symbols are pads: stop
469 if ((flags
& CTF_SYMTYPETAB_EMIT_PAD
) && idx
[i
]->st_symidx
== outmax
)
476 /* Emit an objt or func symtypetab index into DP in a paticular order defined by
477 an array of symbol names passed in. Stop at NIDX. The linker-reported set
478 of symbols (if any) is found in SYMFP. */
480 emit_symtypetab_index (ctf_dict_t
*fp
, ctf_dict_t
*symfp
, uint32_t *dp
,
481 const char **idx
, uint32_t nidx
, int size
, int flags
)
485 ctf_dynhash_t
*symhash
;
487 ctf_dprintf ("Emitting index of size %i, %u entries reported by linker, "
488 "flags %i\n", size
, nidx
, flags
);
490 /* Empty table? Nothing to do. */
494 if (flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
495 symhash
= fp
->ctf_funchash
;
497 symhash
= fp
->ctf_objthash
;
499 /* Indexes should always be unpadded. */
500 if (!ctf_assert (fp
, !(flags
& CTF_SYMTYPETAB_EMIT_PAD
)))
501 return -1; /* errno is set for us. */
503 for (i
= 0; i
< nidx
; i
++)
505 const char *sym_name
;
508 if (!(flags
& CTF_SYMTYPETAB_FORCE_INDEXED
))
510 ctf_link_sym_t
*this_link_sym
;
512 this_link_sym
= ctf_dynhash_lookup (symfp
->ctf_dynsyms
, idx
[i
]);
514 /* This is an index: unreported symbols should never appear in it. */
515 if (!ctf_assert (fp
, this_link_sym
!= NULL
))
516 return -1; /* errno is set for us. */
518 /* Symbol of the wrong type, or skippable? This symbol is not in this
520 if (((flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
521 && this_link_sym
->st_type
!= STT_FUNC
)
522 || (!(flags
& CTF_SYMTYPETAB_EMIT_FUNCTION
)
523 && this_link_sym
->st_type
!= STT_OBJECT
))
526 if (ctf_symtab_skippable (this_link_sym
))
529 sym_name
= this_link_sym
->st_name
;
531 /* Linker reports symbol of a different type to the symbol we actually
532 added? Skip the symbol. */
533 if ((this_link_sym
->st_type
== STT_FUNC
)
534 && (ctf_dynhash_lookup (fp
->ctf_objthash
, sym_name
)))
537 if ((this_link_sym
->st_type
== STT_OBJECT
)
538 && (ctf_dynhash_lookup (fp
->ctf_funchash
, sym_name
)))
544 /* Symbol in index and reported by linker, but no type set? Silently skip
545 and (optionally) pad. (In force-indexed mode, this is also where we
546 track symbols of the wrong type for this round of insertion.) */
547 if ((type
= ctf_dynhash_lookup (symhash
, sym_name
)) == NULL
)
550 ctf_str_add_ref (fp
, sym_name
, dpp
++);
552 if (!ctf_assert (fp
, (((char *) dpp
) - (char *) dp
) <= size
))
553 return -1; /* errno is set for us. */
559 static unsigned char *
560 ctf_copy_smembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
562 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
565 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
567 ctf_member_t
*copied
;
570 ctm
.ctm_type
= (uint32_t) dmd
->dmd_type
;
571 ctm
.ctm_offset
= (uint32_t) dmd
->dmd_offset
;
573 memcpy (t
, &ctm
, sizeof (ctm
));
574 copied
= (ctf_member_t
*) t
;
576 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctm_name
);
584 static unsigned char *
585 ctf_copy_lmembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
587 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
590 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
592 ctf_lmember_t
*copied
;
595 ctlm
.ctlm_type
= (uint32_t) dmd
->dmd_type
;
596 ctlm
.ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (dmd
->dmd_offset
);
597 ctlm
.ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (dmd
->dmd_offset
);
599 memcpy (t
, &ctlm
, sizeof (ctlm
));
600 copied
= (ctf_lmember_t
*) t
;
602 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->ctlm_name
);
610 static unsigned char *
611 ctf_copy_emembers (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, unsigned char *t
)
613 ctf_dmdef_t
*dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
616 for (; dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
620 cte
.cte_value
= dmd
->dmd_value
;
621 memcpy (t
, &cte
, sizeof (cte
));
622 copied
= (ctf_enum_t
*) t
;
623 ctf_str_add_ref (fp
, dmd
->dmd_name
, &copied
->cte_name
);
630 /* Sort a newly-constructed static variable array. */
632 typedef struct ctf_sort_var_arg_cb
636 } ctf_sort_var_arg_cb_t
;
639 ctf_sort_var (const void *one_
, const void *two_
, void *arg_
)
641 const ctf_varent_t
*one
= one_
;
642 const ctf_varent_t
*two
= two_
;
643 ctf_sort_var_arg_cb_t
*arg
= arg_
;
645 return (strcmp (ctf_strraw_explicit (arg
->fp
, one
->ctv_name
, arg
->strtab
),
646 ctf_strraw_explicit (arg
->fp
, two
->ctv_name
, arg
->strtab
)));
649 /* Compatibility: just update the threshold for ctf_discard. */
651 ctf_update (ctf_dict_t
*fp
)
653 if (!(fp
->ctf_flags
& LCTF_RDWR
))
654 return (ctf_set_errno (fp
, ECTF_RDONLY
));
656 fp
->ctf_dtoldid
= fp
->ctf_typemax
;
660 /* If the specified CTF dict is writable and has been modified, reload this dict
661 with the updated type definitions, ready for serialization. In order to make
662 this code and the rest of libctf as simple as possible, we perform updates by
663 taking the dynamic type definitions and creating an in-memory CTF dict
664 containing the definitions, and then call ctf_simple_open_internal() on it.
665 We perform one extra trick here for the benefit of callers and to keep our
666 code simple: ctf_simple_open_internal() will return a new ctf_dict_t, but we
667 want to keep the fp constant for the caller, so after
668 ctf_simple_open_internal() returns, we use memcpy to swap the interior of the
669 old and new ctf_dict_t's, and then free the old. */
671 ctf_serialize (ctf_dict_t
*fp
)
673 ctf_dict_t ofp
, *nfp
;
674 ctf_header_t hdr
, *hdrp
;
677 ctf_varent_t
*dvarents
;
678 ctf_strs_writable_t strtab
;
679 ctf_dict_t
*symfp
= fp
;
684 size_t buf_size
, type_size
, objt_size
, func_size
;
685 size_t objt_unpadsize
, func_unpadsize
, objt_padsize
, func_padsize
;
686 size_t funcidx_size
, objtidx_size
;
687 size_t nvars
, nfuncs
, nobjts
, maxobjt
, maxfunc
;
689 const char **sym_name_order
= NULL
;
690 unsigned char *buf
= NULL
, *newbuf
;
693 if (!(fp
->ctf_flags
& LCTF_RDWR
))
694 return (ctf_set_errno (fp
, ECTF_RDONLY
));
696 /* Update required? */
697 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
700 /* Fill in an initial CTF header. We will leave the label, object,
701 and function sections empty and only output a header, type section,
702 and string table. The type section begins at a 4-byte aligned
703 boundary past the CTF header itself (at relative offset zero). The flag
704 indicating a new-style function info section (an array of CTF_K_FUNCTION
705 type IDs in the types section) is flipped on. */
707 memset (&hdr
, 0, sizeof (hdr
));
708 hdr
.cth_magic
= CTF_MAGIC
;
709 hdr
.cth_version
= CTF_VERSION
;
711 /* This is a new-format func info section, and the symtab and strtab come out
712 of the dynsym and dynstr these days. */
713 hdr
.cth_flags
= (CTF_F_NEWFUNCINFO
| CTF_F_DYNSTR
);
715 /* Iterate through the dynamic type definition list and compute the
716 size of the CTF type section we will need to generate. */
718 for (type_size
= 0, dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
719 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
721 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
722 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
724 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
725 type_size
+= sizeof (ctf_stype_t
);
727 type_size
+= sizeof (ctf_type_t
);
733 type_size
+= sizeof (uint32_t);
736 type_size
+= sizeof (ctf_array_t
);
739 type_size
+= sizeof (ctf_slice_t
);
742 type_size
+= sizeof (uint32_t) * (vlen
+ (vlen
& 1));
746 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
747 type_size
+= sizeof (ctf_member_t
) * vlen
;
749 type_size
+= sizeof (ctf_lmember_t
) * vlen
;
752 type_size
+= sizeof (ctf_enum_t
) * vlen
;
757 /* Symbol table stuff is done only if the linker has told this dict about
758 potential symbols (usually the case for parent dicts only). The linker
759 will report symbols to the parent dict in a parent/child link, as usual
760 with all linker-related matters. */
762 if (!fp
->ctf_dynsyms
&& fp
->ctf_parent
&& fp
->ctf_parent
->ctf_dynsyms
)
763 symfp
= fp
->ctf_parent
;
765 /* No linker-reported symbols at all: ctf_link_shuffle_syms was never called.
766 This must be an unsorted, indexed dict. Otherwise, this is a sorted
767 dict, and the header flags indicate as much. */
768 if (!symfp
->ctf_dynsyms
)
769 symflags
= CTF_SYMTYPETAB_FORCE_INDEXED
;
771 hdr
.cth_flags
|= CTF_F_IDXSORTED
;
773 /* Work out the sizes of the object and function sections, and work out the
774 number of pad (unassigned) symbols in each, and the overall size of the
777 if (symtypetab_density (fp
, symfp
, fp
->ctf_objthash
, &nobjts
, &maxobjt
,
778 &objt_unpadsize
, &objt_padsize
, &objtidx_size
,
780 return -1; /* errno is set for us. */
782 ctf_dprintf ("Object symtypetab: %i objects, max %i, unpadded size %i, "
783 "%i bytes of pads, index size %i\n", (int) nobjts
, (int) maxobjt
,
784 (int) objt_unpadsize
, (int) objt_padsize
, (int) objtidx_size
);
786 if (symtypetab_density (fp
, symfp
, fp
->ctf_funchash
, &nfuncs
, &maxfunc
,
787 &func_unpadsize
, &func_padsize
, &funcidx_size
,
788 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
789 return -1; /* errno is set for us. */
791 ctf_dprintf ("Function symtypetab: %i functions, max %i, unpadded size %i, "
792 "%i bytes of pads, index size %i\n", (int) nfuncs
, (int) maxfunc
,
793 (int) func_unpadsize
, (int) func_padsize
, (int) funcidx_size
);
795 /* If the linker has reported any symbols at all, those symbols that the
796 linker has not reported are now removed from the ctf_objthash and
797 ctf_funchash. Delete entries from the variable section that duplicate
798 newly-added data symbols. There's no need to migrate new ones in, because
799 linker invocations (even ld -r) can only introduce new symbols, not remove
800 symbols that already exist, and the compiler always emits both a variable
801 and a data symbol simultaneously. */
803 if (symtypetab_delete_nonstatic_vars (fp
) < 0)
806 /* It is worth indexing each section if it would save space to do so, due to
807 reducing the number of pads sufficiently. A pad is the same size as a
808 single index entry: but index sections compress relatively poorly compared
809 to constant pads, so it takes a lot of contiguous padding to equal one
810 index section entry. It would be nice to be able to *verify* whether we
811 would save space after compression rather than guessing, but this seems
812 difficult, since it would require complete reserialization. Regardless, if
813 the linker has not reported any symbols (e.g. if this is not a final link
814 but just an ld -r), we must emit things in indexed fashion just as the
817 objt_size
= objt_unpadsize
;
818 if (!(symflags
& CTF_SYMTYPETAB_FORCE_INDEXED
)
819 && ((objt_padsize
+ objt_unpadsize
) * CTF_INDEX_PAD_THRESHOLD
822 objt_size
+= objt_padsize
;
826 func_size
= func_unpadsize
;
827 if (!(symflags
& CTF_SYMTYPETAB_FORCE_INDEXED
)
828 && ((func_padsize
+ func_unpadsize
) * CTF_INDEX_PAD_THRESHOLD
831 func_size
+= func_padsize
;
835 /* Computing the number of entries in the CTF variable section is much
838 for (nvars
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
);
839 dvd
!= NULL
; dvd
= ctf_list_next (dvd
), nvars
++);
841 /* Compute the size of the CTF buffer we need, sans only the string table,
842 then allocate a new buffer and memcpy the finished header to the start of
843 the buffer. (We will adjust this later with strtab length info.) */
845 hdr
.cth_lbloff
= hdr
.cth_objtoff
= 0;
846 hdr
.cth_funcoff
= hdr
.cth_objtoff
+ objt_size
;
847 hdr
.cth_objtidxoff
= hdr
.cth_funcoff
+ func_size
;
848 hdr
.cth_funcidxoff
= hdr
.cth_objtidxoff
+ objtidx_size
;
849 hdr
.cth_varoff
= hdr
.cth_funcidxoff
+ funcidx_size
;
850 hdr
.cth_typeoff
= hdr
.cth_varoff
+ (nvars
* sizeof (ctf_varent_t
));
851 hdr
.cth_stroff
= hdr
.cth_typeoff
+ type_size
;
854 buf_size
= sizeof (ctf_header_t
) + hdr
.cth_stroff
+ hdr
.cth_strlen
;
856 if ((buf
= malloc (buf_size
)) == NULL
)
857 return (ctf_set_errno (fp
, EAGAIN
));
859 memcpy (buf
, &hdr
, sizeof (ctf_header_t
));
860 t
= (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_objtoff
;
862 hdrp
= (ctf_header_t
*) buf
;
863 if ((fp
->ctf_flags
& LCTF_CHILD
) && (fp
->ctf_parname
!= NULL
))
864 ctf_str_add_ref (fp
, fp
->ctf_parname
, &hdrp
->cth_parname
);
865 if (fp
->ctf_cuname
!= NULL
)
866 ctf_str_add_ref (fp
, fp
->ctf_cuname
, &hdrp
->cth_cuname
);
868 /* Sort the linker's symbols into name order if need be: if
869 ctf_link_shuffle_syms has not been called at all, just use all the symbols
870 that were added to this dict, and don't bother sorting them since this is
871 probably an ld -r and will likely just be consumed by ld again, with no
872 ctf_lookup_by_symbol()s ever done on it. */
874 if ((objtidx_size
!= 0) || (funcidx_size
!= 0))
876 ctf_next_t
*i
= NULL
;
881 if (symfp
->ctf_dynsyms
)
882 ndynsyms
= ctf_dynhash_elements (symfp
->ctf_dynsyms
);
884 ndynsyms
= ctf_dynhash_elements (symfp
->ctf_objthash
)
885 + ctf_dynhash_elements (symfp
->ctf_funchash
);
887 if ((sym_name_order
= calloc (ndynsyms
, sizeof (const char *))) == NULL
)
890 walk
= sym_name_order
;
892 if (symfp
->ctf_dynsyms
)
894 while ((err
= ctf_dynhash_next_sorted (symfp
->ctf_dynsyms
, &i
, &symname
,
895 NULL
, ctf_dynhash_sort_by_name
,
897 *walk
++ = (const char *) symname
;
898 if (err
!= ECTF_NEXT_END
)
903 while ((err
= ctf_dynhash_next (symfp
->ctf_objthash
, &i
, &symname
,
905 *walk
++ = (const char *) symname
;
906 if (err
!= ECTF_NEXT_END
)
909 while ((err
= ctf_dynhash_next (symfp
->ctf_funchash
, &i
, &symname
,
911 *walk
++ = (const char *) symname
;
912 if (err
!= ECTF_NEXT_END
)
917 /* Emit the object and function sections, and if necessary their indexes.
918 Emission is done in symtab order if there is no index, and in index
919 (name) order otherwise. */
921 if ((objtidx_size
== 0) && symfp
->ctf_dynsymidx
)
923 ctf_dprintf ("Emitting unindexed objt symtypetab\n");
924 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
925 NULL
, symfp
->ctf_dynsymmax
+ 1, maxobjt
, objt_size
,
926 symflags
| CTF_SYMTYPETAB_EMIT_PAD
) < 0)
927 goto err
; /* errno is set for us. */
931 ctf_dprintf ("Emitting indexed objt symtypetab\n");
932 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
933 ndynsyms
, maxobjt
, objt_size
, symflags
) < 0)
934 goto err
; /* errno is set for us. */
939 if ((funcidx_size
== 0) && symfp
->ctf_dynsymidx
)
941 ctf_dprintf ("Emitting unindexed func symtypetab\n");
942 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, symfp
->ctf_dynsymidx
,
943 NULL
, symfp
->ctf_dynsymmax
+ 1, maxfunc
,
944 func_size
, symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
945 | CTF_SYMTYPETAB_EMIT_PAD
) < 0)
946 goto err
; /* errno is set for us. */
950 ctf_dprintf ("Emitting indexed func symtypetab\n");
951 if (emit_symtypetab (fp
, symfp
, (uint32_t *) t
, NULL
, sym_name_order
,
952 ndynsyms
, maxfunc
, func_size
,
953 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
954 goto err
; /* errno is set for us. */
959 if (objtidx_size
> 0)
960 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
961 ndynsyms
, objtidx_size
, symflags
) < 0)
966 if (funcidx_size
> 0)
967 if (emit_symtypetab_index (fp
, symfp
, (uint32_t *) t
, sym_name_order
,
968 ndynsyms
, funcidx_size
,
969 symflags
| CTF_SYMTYPETAB_EMIT_FUNCTION
) < 0)
973 free (sym_name_order
);
974 sym_name_order
= NULL
;
976 /* Work over the variable list, translating everything into ctf_varent_t's and
977 prepping the string table. */
979 dvarents
= (ctf_varent_t
*) t
;
980 for (i
= 0, dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
;
981 dvd
= ctf_list_next (dvd
), i
++)
983 ctf_varent_t
*var
= &dvarents
[i
];
985 ctf_str_add_ref (fp
, dvd
->dvd_name
, &var
->ctv_name
);
986 var
->ctv_type
= (uint32_t) dvd
->dvd_type
;
990 t
+= sizeof (ctf_varent_t
) * nvars
;
992 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_typeoff
);
994 /* We now take a final lap through the dynamic type definition list and copy
995 the appropriate type records to the output buffer, noting down the
998 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
);
999 dtd
!= NULL
; dtd
= ctf_list_next (dtd
))
1001 uint32_t kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1002 uint32_t vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1007 ctf_stype_t
*copied
;
1010 if (dtd
->dtd_data
.ctt_size
!= CTF_LSIZE_SENT
)
1011 len
= sizeof (ctf_stype_t
);
1013 len
= sizeof (ctf_type_t
);
1015 memcpy (t
, &dtd
->dtd_data
, len
);
1016 copied
= (ctf_stype_t
*) t
; /* name is at the start: constant offset. */
1017 if (copied
->ctt_name
1018 && (name
= ctf_strraw (fp
, copied
->ctt_name
)) != NULL
)
1019 ctf_str_add_ref (fp
, name
, &copied
->ctt_name
);
1026 if (kind
== CTF_K_INTEGER
)
1028 encoding
= CTF_INT_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1029 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1030 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1034 encoding
= CTF_FP_DATA (dtd
->dtd_u
.dtu_enc
.cte_format
,
1035 dtd
->dtd_u
.dtu_enc
.cte_offset
,
1036 dtd
->dtd_u
.dtu_enc
.cte_bits
);
1038 memcpy (t
, &encoding
, sizeof (encoding
));
1039 t
+= sizeof (encoding
);
1043 memcpy (t
, &dtd
->dtd_u
.dtu_slice
, sizeof (struct ctf_slice
));
1044 t
+= sizeof (struct ctf_slice
);
1048 cta
.cta_contents
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_contents
;
1049 cta
.cta_index
= (uint32_t) dtd
->dtd_u
.dtu_arr
.ctr_index
;
1050 cta
.cta_nelems
= dtd
->dtd_u
.dtu_arr
.ctr_nelems
;
1051 memcpy (t
, &cta
, sizeof (cta
));
1055 case CTF_K_FUNCTION
:
1057 uint32_t *argv
= (uint32_t *) (uintptr_t) t
;
1060 for (argc
= 0; argc
< vlen
; argc
++)
1061 *argv
++ = dtd
->dtd_u
.dtu_argv
[argc
];
1064 *argv
++ = 0; /* Pad to 4-byte boundary. */
1066 t
= (unsigned char *) argv
;
1072 if (dtd
->dtd_data
.ctt_size
< CTF_LSTRUCT_THRESH
)
1073 t
= ctf_copy_smembers (fp
, dtd
, t
);
1075 t
= ctf_copy_lmembers (fp
, dtd
, t
);
1079 t
= ctf_copy_emembers (fp
, dtd
, t
);
1083 assert (t
== (unsigned char *) buf
+ sizeof (ctf_header_t
) + hdr
.cth_stroff
);
1085 /* Construct the final string table and fill out all the string refs with the
1086 final offsets. Then purge the refs list, because we're about to move this
1087 strtab onto the end of the buf, invalidating all the offsets. */
1088 strtab
= ctf_str_write_strtab (fp
);
1089 ctf_str_purge_refs (fp
);
1091 if (strtab
.cts_strs
== NULL
)
1094 /* Now the string table is constructed, we can sort the buffer of
1096 ctf_sort_var_arg_cb_t sort_var_arg
= { fp
, (ctf_strs_t
*) &strtab
};
1097 ctf_qsort_r (dvarents
, nvars
, sizeof (ctf_varent_t
), ctf_sort_var
,
1100 if ((newbuf
= ctf_realloc (fp
, buf
, buf_size
+ strtab
.cts_len
)) == NULL
)
1102 free (strtab
.cts_strs
);
1106 memcpy (buf
+ buf_size
, strtab
.cts_strs
, strtab
.cts_len
);
1107 hdrp
= (ctf_header_t
*) buf
;
1108 hdrp
->cth_strlen
= strtab
.cts_len
;
1109 buf_size
+= hdrp
->cth_strlen
;
1110 free (strtab
.cts_strs
);
1112 /* Finally, we are ready to ctf_simple_open() the new dict. If this is
1113 successful, we then switch nfp and fp and free the old dict. */
1115 if ((nfp
= ctf_simple_open_internal ((char *) buf
, buf_size
, NULL
, 0,
1116 0, NULL
, 0, fp
->ctf_syn_ext_strtab
,
1120 return (ctf_set_errno (fp
, err
));
1123 (void) ctf_setmodel (nfp
, ctf_getmodel (fp
));
1125 nfp
->ctf_parent
= fp
->ctf_parent
;
1126 nfp
->ctf_parent_unreffed
= fp
->ctf_parent_unreffed
;
1127 nfp
->ctf_refcnt
= fp
->ctf_refcnt
;
1128 nfp
->ctf_flags
|= fp
->ctf_flags
& ~LCTF_DIRTY
;
1129 if (nfp
->ctf_dynbase
== NULL
)
1130 nfp
->ctf_dynbase
= buf
; /* Make sure buf is freed on close. */
1131 nfp
->ctf_dthash
= fp
->ctf_dthash
;
1132 nfp
->ctf_dtdefs
= fp
->ctf_dtdefs
;
1133 nfp
->ctf_dvhash
= fp
->ctf_dvhash
;
1134 nfp
->ctf_dvdefs
= fp
->ctf_dvdefs
;
1135 nfp
->ctf_dtoldid
= fp
->ctf_dtoldid
;
1136 nfp
->ctf_add_processing
= fp
->ctf_add_processing
;
1137 nfp
->ctf_snapshots
= fp
->ctf_snapshots
+ 1;
1138 nfp
->ctf_specific
= fp
->ctf_specific
;
1139 nfp
->ctf_nfuncidx
= fp
->ctf_nfuncidx
;
1140 nfp
->ctf_nobjtidx
= fp
->ctf_nobjtidx
;
1141 nfp
->ctf_objthash
= fp
->ctf_objthash
;
1142 nfp
->ctf_funchash
= fp
->ctf_funchash
;
1143 nfp
->ctf_dynsyms
= fp
->ctf_dynsyms
;
1144 nfp
->ctf_ptrtab
= fp
->ctf_ptrtab
;
1145 nfp
->ctf_dynsymidx
= fp
->ctf_dynsymidx
;
1146 nfp
->ctf_dynsymmax
= fp
->ctf_dynsymmax
;
1147 nfp
->ctf_ptrtab_len
= fp
->ctf_ptrtab_len
;
1148 nfp
->ctf_link_inputs
= fp
->ctf_link_inputs
;
1149 nfp
->ctf_link_outputs
= fp
->ctf_link_outputs
;
1150 nfp
->ctf_errs_warnings
= fp
->ctf_errs_warnings
;
1151 nfp
->ctf_funcidx_names
= fp
->ctf_funcidx_names
;
1152 nfp
->ctf_objtidx_names
= fp
->ctf_objtidx_names
;
1153 nfp
->ctf_funcidx_sxlate
= fp
->ctf_funcidx_sxlate
;
1154 nfp
->ctf_objtidx_sxlate
= fp
->ctf_objtidx_sxlate
;
1155 nfp
->ctf_str_prov_offset
= fp
->ctf_str_prov_offset
;
1156 nfp
->ctf_syn_ext_strtab
= fp
->ctf_syn_ext_strtab
;
1157 nfp
->ctf_in_flight_dynsyms
= fp
->ctf_in_flight_dynsyms
;
1158 nfp
->ctf_link_in_cu_mapping
= fp
->ctf_link_in_cu_mapping
;
1159 nfp
->ctf_link_out_cu_mapping
= fp
->ctf_link_out_cu_mapping
;
1160 nfp
->ctf_link_type_mapping
= fp
->ctf_link_type_mapping
;
1161 nfp
->ctf_link_memb_name_changer
= fp
->ctf_link_memb_name_changer
;
1162 nfp
->ctf_link_memb_name_changer_arg
= fp
->ctf_link_memb_name_changer_arg
;
1163 nfp
->ctf_link_variable_filter
= fp
->ctf_link_variable_filter
;
1164 nfp
->ctf_link_variable_filter_arg
= fp
->ctf_link_variable_filter_arg
;
1165 nfp
->ctf_symsect_little_endian
= fp
->ctf_symsect_little_endian
;
1166 nfp
->ctf_link_flags
= fp
->ctf_link_flags
;
1167 nfp
->ctf_dedup_atoms
= fp
->ctf_dedup_atoms
;
1168 nfp
->ctf_dedup_atoms_alloc
= fp
->ctf_dedup_atoms_alloc
;
1169 memcpy (&nfp
->ctf_dedup
, &fp
->ctf_dedup
, sizeof (fp
->ctf_dedup
));
1171 nfp
->ctf_snapshot_lu
= fp
->ctf_snapshots
;
1173 memcpy (&nfp
->ctf_lookups
, fp
->ctf_lookups
, sizeof (fp
->ctf_lookups
));
1174 nfp
->ctf_structs
= fp
->ctf_structs
;
1175 nfp
->ctf_unions
= fp
->ctf_unions
;
1176 nfp
->ctf_enums
= fp
->ctf_enums
;
1177 nfp
->ctf_names
= fp
->ctf_names
;
1179 fp
->ctf_dthash
= NULL
;
1180 ctf_str_free_atoms (nfp
);
1181 nfp
->ctf_str_atoms
= fp
->ctf_str_atoms
;
1182 nfp
->ctf_prov_strtab
= fp
->ctf_prov_strtab
;
1183 fp
->ctf_str_atoms
= NULL
;
1184 fp
->ctf_prov_strtab
= NULL
;
1185 memset (&fp
->ctf_dtdefs
, 0, sizeof (ctf_list_t
));
1186 memset (&fp
->ctf_errs_warnings
, 0, sizeof (ctf_list_t
));
1187 fp
->ctf_add_processing
= NULL
;
1188 fp
->ctf_ptrtab
= NULL
;
1189 fp
->ctf_funcidx_names
= NULL
;
1190 fp
->ctf_objtidx_names
= NULL
;
1191 fp
->ctf_funcidx_sxlate
= NULL
;
1192 fp
->ctf_objtidx_sxlate
= NULL
;
1193 fp
->ctf_objthash
= NULL
;
1194 fp
->ctf_funchash
= NULL
;
1195 fp
->ctf_dynsyms
= NULL
;
1196 fp
->ctf_dynsymidx
= NULL
;
1197 fp
->ctf_link_inputs
= NULL
;
1198 fp
->ctf_link_outputs
= NULL
;
1199 fp
->ctf_syn_ext_strtab
= NULL
;
1200 fp
->ctf_link_in_cu_mapping
= NULL
;
1201 fp
->ctf_link_out_cu_mapping
= NULL
;
1202 fp
->ctf_link_type_mapping
= NULL
;
1203 fp
->ctf_dedup_atoms
= NULL
;
1204 fp
->ctf_dedup_atoms_alloc
= NULL
;
1205 fp
->ctf_parent_unreffed
= 1;
1207 fp
->ctf_dvhash
= NULL
;
1208 memset (&fp
->ctf_dvdefs
, 0, sizeof (ctf_list_t
));
1209 memset (fp
->ctf_lookups
, 0, sizeof (fp
->ctf_lookups
));
1210 memset (&fp
->ctf_in_flight_dynsyms
, 0, sizeof (fp
->ctf_in_flight_dynsyms
));
1211 memset (&fp
->ctf_dedup
, 0, sizeof (fp
->ctf_dedup
));
1212 fp
->ctf_structs
.ctn_writable
= NULL
;
1213 fp
->ctf_unions
.ctn_writable
= NULL
;
1214 fp
->ctf_enums
.ctn_writable
= NULL
;
1215 fp
->ctf_names
.ctn_writable
= NULL
;
1217 memcpy (&ofp
, fp
, sizeof (ctf_dict_t
));
1218 memcpy (fp
, nfp
, sizeof (ctf_dict_t
));
1219 memcpy (nfp
, &ofp
, sizeof (ctf_dict_t
));
1221 nfp
->ctf_refcnt
= 1; /* Force nfp to be freed. */
1222 ctf_dict_close (nfp
);
1227 ctf_err_warn (fp
, 0, err
, _("error serializing symtypetabs"));
1231 free (sym_name_order
);
1232 return (ctf_set_errno (fp
, EAGAIN
));
1235 free (sym_name_order
);
1236 return -1; /* errno is set for us. */
1240 ctf_name_table (ctf_dict_t
*fp
, int kind
)
1245 return &fp
->ctf_structs
;
1247 return &fp
->ctf_unions
;
1249 return &fp
->ctf_enums
;
1251 return &fp
->ctf_names
;
1256 ctf_dtd_insert (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
, int flag
, int kind
)
1259 if (ctf_dynhash_insert (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
,
1262 ctf_set_errno (fp
, ENOMEM
);
1266 if (flag
== CTF_ADD_ROOT
&& dtd
->dtd_data
.ctt_name
1267 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
)
1269 if (ctf_dynhash_insert (ctf_name_table (fp
, kind
)->ctn_writable
,
1270 (char *) name
, (void *) (uintptr_t)
1273 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t)
1275 ctf_set_errno (fp
, ENOMEM
);
1279 ctf_list_append (&fp
->ctf_dtdefs
, dtd
);
1284 ctf_dtd_delete (ctf_dict_t
*fp
, ctf_dtdef_t
*dtd
)
1286 ctf_dmdef_t
*dmd
, *nmd
;
1287 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1288 int name_kind
= kind
;
1291 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1298 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
1299 dmd
!= NULL
; dmd
= nmd
)
1301 if (dmd
->dmd_name
!= NULL
)
1302 free (dmd
->dmd_name
);
1303 nmd
= ctf_list_next (dmd
);
1307 case CTF_K_FUNCTION
:
1308 free (dtd
->dtd_u
.dtu_argv
);
1311 name_kind
= dtd
->dtd_data
.ctt_type
;
1315 if (dtd
->dtd_data
.ctt_name
1316 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1317 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1319 ctf_dynhash_remove (ctf_name_table (fp
, name_kind
)->ctn_writable
,
1321 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1324 ctf_list_delete (&fp
->ctf_dtdefs
, dtd
);
1329 ctf_dtd_lookup (const ctf_dict_t
*fp
, ctf_id_t type
)
1331 return (ctf_dtdef_t
*)
1332 ctf_dynhash_lookup (fp
->ctf_dthash
, (void *) (uintptr_t) type
);
1336 ctf_dynamic_type (const ctf_dict_t
*fp
, ctf_id_t id
)
1340 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1343 if ((fp
->ctf_flags
& LCTF_CHILD
) && LCTF_TYPE_ISPARENT (fp
, id
))
1344 fp
= fp
->ctf_parent
;
1346 idx
= LCTF_TYPE_TO_INDEX(fp
, id
);
1348 if ((unsigned long) idx
<= fp
->ctf_typemax
)
1349 return ctf_dtd_lookup (fp
, id
);
1354 ctf_dvd_insert (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1356 if (ctf_dynhash_insert (fp
->ctf_dvhash
, dvd
->dvd_name
, dvd
) < 0)
1358 ctf_set_errno (fp
, ENOMEM
);
1361 ctf_list_append (&fp
->ctf_dvdefs
, dvd
);
1366 ctf_dvd_delete (ctf_dict_t
*fp
, ctf_dvdef_t
*dvd
)
1368 ctf_dynhash_remove (fp
->ctf_dvhash
, dvd
->dvd_name
);
1369 free (dvd
->dvd_name
);
1371 ctf_list_delete (&fp
->ctf_dvdefs
, dvd
);
1376 ctf_dvd_lookup (const ctf_dict_t
*fp
, const char *name
)
1378 return (ctf_dvdef_t
*) ctf_dynhash_lookup (fp
->ctf_dvhash
, name
);
1381 /* Discard all of the dynamic type definitions and variable definitions that
1382 have been added to the dict since the last call to ctf_update(). We locate
1383 such types by scanning the dtd list and deleting elements that have type IDs
1384 greater than ctf_dtoldid, which is set by ctf_update(), above, and by
1385 scanning the variable list and deleting elements that have update IDs equal
1386 to the current value of the last-update snapshot count (indicating that they
1387 were added after the most recent call to ctf_update()). */
1389 ctf_discard (ctf_dict_t
*fp
)
1391 ctf_snapshot_id_t last_update
=
1393 fp
->ctf_snapshot_lu
+ 1 };
1395 /* Update required? */
1396 if (!(fp
->ctf_flags
& LCTF_DIRTY
))
1399 return (ctf_rollback (fp
, last_update
));
1403 ctf_snapshot (ctf_dict_t
*fp
)
1405 ctf_snapshot_id_t snapid
;
1406 snapid
.dtd_id
= fp
->ctf_typemax
;
1407 snapid
.snapshot_id
= fp
->ctf_snapshots
++;
1411 /* Like ctf_discard(), only discards everything after a particular ID. */
1413 ctf_rollback (ctf_dict_t
*fp
, ctf_snapshot_id_t id
)
1415 ctf_dtdef_t
*dtd
, *ntd
;
1416 ctf_dvdef_t
*dvd
, *nvd
;
1418 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1419 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1421 if (fp
->ctf_snapshot_lu
>= id
.snapshot_id
)
1422 return (ctf_set_errno (fp
, ECTF_OVERROLLBACK
));
1424 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1429 ntd
= ctf_list_next (dtd
);
1431 if (LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_type
) <= id
.dtd_id
)
1434 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1435 if (kind
== CTF_K_FORWARD
)
1436 kind
= dtd
->dtd_data
.ctt_type
;
1438 if (dtd
->dtd_data
.ctt_name
1439 && (name
= ctf_strraw (fp
, dtd
->dtd_data
.ctt_name
)) != NULL
1440 && LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
))
1442 ctf_dynhash_remove (ctf_name_table (fp
, kind
)->ctn_writable
,
1444 ctf_str_remove_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1447 ctf_dynhash_remove (fp
->ctf_dthash
, (void *) (uintptr_t) dtd
->dtd_type
);
1448 ctf_dtd_delete (fp
, dtd
);
1451 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1453 nvd
= ctf_list_next (dvd
);
1455 if (dvd
->dvd_snapshots
<= id
.snapshot_id
)
1458 ctf_dvd_delete (fp
, dvd
);
1461 fp
->ctf_typemax
= id
.dtd_id
;
1462 fp
->ctf_snapshots
= id
.snapshot_id
;
1464 if (fp
->ctf_snapshots
== fp
->ctf_snapshot_lu
)
1465 fp
->ctf_flags
&= ~LCTF_DIRTY
;
1471 ctf_add_generic (ctf_dict_t
*fp
, uint32_t flag
, const char *name
, int kind
,
1477 if (flag
!= CTF_ADD_NONROOT
&& flag
!= CTF_ADD_ROOT
)
1478 return (ctf_set_errno (fp
, EINVAL
));
1480 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1481 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1483 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) >= CTF_MAX_TYPE
)
1484 return (ctf_set_errno (fp
, ECTF_FULL
));
1486 if (LCTF_INDEX_TO_TYPE (fp
, fp
->ctf_typemax
, 1) == (CTF_MAX_PTYPE
- 1))
1487 return (ctf_set_errno (fp
, ECTF_FULL
));
1489 /* Make sure ptrtab always grows to be big enough for all types. */
1490 if (ctf_grow_ptrtab (fp
) < 0)
1491 return CTF_ERR
; /* errno is set for us. */
1493 if ((dtd
= malloc (sizeof (ctf_dtdef_t
))) == NULL
)
1494 return (ctf_set_errno (fp
, EAGAIN
));
1496 type
= ++fp
->ctf_typemax
;
1497 type
= LCTF_INDEX_TO_TYPE (fp
, type
, (fp
->ctf_flags
& LCTF_CHILD
));
1499 memset (dtd
, 0, sizeof (ctf_dtdef_t
));
1500 dtd
->dtd_data
.ctt_name
= ctf_str_add_ref (fp
, name
, &dtd
->dtd_data
.ctt_name
);
1501 dtd
->dtd_type
= type
;
1503 if (dtd
->dtd_data
.ctt_name
== 0 && name
!= NULL
&& name
[0] != '\0')
1506 return (ctf_set_errno (fp
, EAGAIN
));
1509 if (ctf_dtd_insert (fp
, dtd
, flag
, kind
) < 0)
1512 return CTF_ERR
; /* errno is set for us. */
1514 fp
->ctf_flags
|= LCTF_DIRTY
;
1520 /* When encoding integer sizes, we want to convert a byte count in the range
1521 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
1522 is a clever implementation from "Hacker's Delight" by Henry Warren, Jr. */
1538 ctf_add_encoded (ctf_dict_t
*fp
, uint32_t flag
,
1539 const char *name
, const ctf_encoding_t
*ep
, uint32_t kind
)
1545 return (ctf_set_errno (fp
, EINVAL
));
1547 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1548 return CTF_ERR
; /* errno is set for us. */
1550 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1551 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1553 dtd
->dtd_u
.dtu_enc
= *ep
;
1559 ctf_add_reftype (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
, uint32_t kind
)
1563 ctf_dict_t
*tmp
= fp
;
1564 int child
= fp
->ctf_flags
& LCTF_CHILD
;
1566 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1567 return (ctf_set_errno (fp
, EINVAL
));
1569 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1570 return CTF_ERR
; /* errno is set for us. */
1572 if ((type
= ctf_add_generic (fp
, flag
, NULL
, kind
, &dtd
)) == CTF_ERR
)
1573 return CTF_ERR
; /* errno is set for us. */
1575 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, 0);
1576 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1578 if (kind
!= CTF_K_POINTER
)
1581 /* If we are adding a pointer, update the ptrtab, both the directly pointed-to
1582 type and (if an anonymous typedef node is being pointed at) the type that
1583 points at too. Note that ctf_typemax is at this point one higher than we
1584 want to check against, because it's just been incremented for the addition
1587 uint32_t type_idx
= LCTF_TYPE_TO_INDEX (fp
, type
);
1588 uint32_t ref_idx
= LCTF_TYPE_TO_INDEX (fp
, ref
);
1590 if (LCTF_TYPE_ISCHILD (fp
, ref
) == child
1591 && ref_idx
< fp
->ctf_typemax
)
1593 fp
->ctf_ptrtab
[ref_idx
] = type_idx
;
1595 ctf_id_t refref_idx
= LCTF_TYPE_TO_INDEX (fp
, dtd
->dtd_data
.ctt_type
);
1598 && (LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) == CTF_K_TYPEDEF
)
1599 && strcmp (ctf_strptr (fp
, dtd
->dtd_data
.ctt_name
), "") == 0
1600 && refref_idx
< fp
->ctf_typemax
)
1601 fp
->ctf_ptrtab
[refref_idx
] = type_idx
;
1608 ctf_add_slice (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
,
1609 const ctf_encoding_t
*ep
)
1612 ctf_id_t resolved_ref
= ref
;
1615 const ctf_type_t
*tp
;
1616 ctf_dict_t
*tmp
= fp
;
1619 return (ctf_set_errno (fp
, EINVAL
));
1621 if ((ep
->cte_bits
> 255) || (ep
->cte_offset
> 255))
1622 return (ctf_set_errno (fp
, ECTF_SLICEOVERFLOW
));
1624 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1625 return (ctf_set_errno (fp
, EINVAL
));
1627 if (ref
!= 0 && ((tp
= ctf_lookup_by_id (&tmp
, ref
)) == NULL
))
1628 return CTF_ERR
; /* errno is set for us. */
1630 /* Make sure we ultimately point to an integral type. We also allow slices to
1631 point to the unimplemented type, for now, because the compiler can emit
1632 such slices, though they're not very much use. */
1634 resolved_ref
= ctf_type_resolve_unsliced (tmp
, ref
);
1635 kind
= ctf_type_kind_unsliced (tmp
, resolved_ref
);
1637 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) &&
1638 (kind
!= CTF_K_ENUM
)
1640 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1642 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_SLICE
, &dtd
)) == CTF_ERR
)
1643 return CTF_ERR
; /* errno is set for us. */
1645 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_SLICE
, flag
, 0);
1646 dtd
->dtd_data
.ctt_size
= clp2 (P2ROUNDUP (ep
->cte_bits
, CHAR_BIT
)
1648 dtd
->dtd_u
.dtu_slice
.cts_type
= (uint32_t) ref
;
1649 dtd
->dtd_u
.dtu_slice
.cts_bits
= ep
->cte_bits
;
1650 dtd
->dtd_u
.dtu_slice
.cts_offset
= ep
->cte_offset
;
1656 ctf_add_integer (ctf_dict_t
*fp
, uint32_t flag
,
1657 const char *name
, const ctf_encoding_t
*ep
)
1659 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_INTEGER
));
1663 ctf_add_float (ctf_dict_t
*fp
, uint32_t flag
,
1664 const char *name
, const ctf_encoding_t
*ep
)
1666 return (ctf_add_encoded (fp
, flag
, name
, ep
, CTF_K_FLOAT
));
1670 ctf_add_pointer (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1672 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_POINTER
));
1676 ctf_add_array (ctf_dict_t
*fp
, uint32_t flag
, const ctf_arinfo_t
*arp
)
1680 ctf_dict_t
*tmp
= fp
;
1683 return (ctf_set_errno (fp
, EINVAL
));
1685 if (arp
->ctr_contents
!= 0
1686 && ctf_lookup_by_id (&tmp
, arp
->ctr_contents
) == NULL
)
1687 return CTF_ERR
; /* errno is set for us. */
1690 if (ctf_lookup_by_id (&tmp
, arp
->ctr_index
) == NULL
)
1691 return CTF_ERR
; /* errno is set for us. */
1693 if (ctf_type_kind (fp
, arp
->ctr_index
) == CTF_K_FORWARD
)
1695 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
1696 _("ctf_add_array: index type %lx is incomplete"),
1698 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
1701 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1702 return CTF_ERR
; /* errno is set for us. */
1704 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1705 dtd
->dtd_data
.ctt_size
= 0;
1706 dtd
->dtd_u
.dtu_arr
= *arp
;
1712 ctf_set_array (ctf_dict_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1714 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1716 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1717 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1720 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1721 return (ctf_set_errno (fp
, ECTF_BADID
));
1723 fp
->ctf_flags
|= LCTF_DIRTY
;
1724 dtd
->dtd_u
.dtu_arr
= *arp
;
1730 ctf_add_function (ctf_dict_t
*fp
, uint32_t flag
,
1731 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1736 uint32_t *vdat
= NULL
;
1737 ctf_dict_t
*tmp
= fp
;
1740 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1741 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1743 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1744 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1745 return (ctf_set_errno (fp
, EINVAL
));
1747 vlen
= ctc
->ctc_argc
;
1748 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1749 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1751 if (ctc
->ctc_return
!= 0
1752 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1753 return CTF_ERR
; /* errno is set for us. */
1755 if (vlen
> CTF_MAX_VLEN
)
1756 return (ctf_set_errno (fp
, EOVERFLOW
));
1758 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1759 return (ctf_set_errno (fp
, EAGAIN
));
1761 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1764 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1767 return CTF_ERR
; /* errno is set for us. */
1769 vdat
[i
] = (uint32_t) argv
[i
];
1772 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1776 return CTF_ERR
; /* errno is set for us. */
1779 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1780 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1782 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1783 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1784 dtd
->dtd_u
.dtu_argv
= vdat
;
1790 ctf_add_struct_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1796 /* Promote root-visible forwards to structs. */
1798 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1800 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1801 dtd
= ctf_dtd_lookup (fp
, type
);
1802 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1804 return CTF_ERR
; /* errno is set for us. */
1806 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1808 if (size
> CTF_MAX_SIZE
)
1810 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1811 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1812 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1815 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1821 ctf_add_struct (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1823 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1827 ctf_add_union_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1833 /* Promote root-visible forwards to unions. */
1835 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1837 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1838 dtd
= ctf_dtd_lookup (fp
, type
);
1839 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1841 return CTF_ERR
; /* errno is set for us */
1843 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1845 if (size
> CTF_MAX_SIZE
)
1847 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1848 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1849 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1852 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1858 ctf_add_union (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1860 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1864 ctf_add_enum (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1869 /* Promote root-visible forwards to enums. */
1871 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1873 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1874 dtd
= ctf_dtd_lookup (fp
, type
);
1875 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1877 return CTF_ERR
; /* errno is set for us. */
1879 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1880 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1886 ctf_add_enum_encoded (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1887 const ctf_encoding_t
*ep
)
1891 /* First, create the enum if need be, using most of the same machinery as
1892 ctf_add_enum(), to ensure that we do not allow things past that are not
1893 enums or forwards to them. (This includes other slices: you cannot slice a
1894 slice, which would be a useless thing to do anyway.) */
1897 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1901 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1902 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1903 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1905 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1906 return CTF_ERR
; /* errno is set for us. */
1908 /* Now attach a suitable slice to it. */
1910 return ctf_add_slice (fp
, flag
, type
, ep
);
1914 ctf_add_forward (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1920 if (!ctf_forwardable_kind (kind
))
1921 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1923 /* If the type is already defined or exists as a forward tag, just
1924 return the ctf_id_t of the existing definition. */
1927 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1932 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1933 return CTF_ERR
; /* errno is set for us. */
1935 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1936 dtd
->dtd_data
.ctt_type
= kind
;
1942 ctf_add_typedef (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1947 ctf_dict_t
*tmp
= fp
;
1949 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1950 return (ctf_set_errno (fp
, EINVAL
));
1952 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1953 return CTF_ERR
; /* errno is set for us. */
1955 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1957 return CTF_ERR
; /* errno is set for us. */
1959 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1960 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1966 ctf_add_volatile (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1968 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1972 ctf_add_const (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1974 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1978 ctf_add_restrict (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1980 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1984 ctf_add_enumerator (ctf_dict_t
*fp
, ctf_id_t enid
, const char *name
,
1987 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1990 uint32_t kind
, vlen
, root
;
1994 return (ctf_set_errno (fp
, EINVAL
));
1996 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1997 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2000 return (ctf_set_errno (fp
, ECTF_BADID
));
2002 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2003 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2004 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2006 if (kind
!= CTF_K_ENUM
)
2007 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
2009 if (vlen
== CTF_MAX_VLEN
)
2010 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2012 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2013 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2015 if (strcmp (dmd
->dmd_name
, name
) == 0)
2016 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2019 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2020 return (ctf_set_errno (fp
, EAGAIN
));
2022 if ((s
= strdup (name
)) == NULL
)
2025 return (ctf_set_errno (fp
, EAGAIN
));
2029 dmd
->dmd_type
= CTF_ERR
;
2030 dmd
->dmd_offset
= 0;
2031 dmd
->dmd_value
= value
;
2033 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2034 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2036 fp
->ctf_flags
|= LCTF_DIRTY
;
2042 ctf_add_member_offset (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2043 ctf_id_t type
, unsigned long bit_offset
)
2045 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
2048 ssize_t msize
, malign
, ssize
;
2049 uint32_t kind
, vlen
, root
;
2051 int is_incomplete
= 0;
2053 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2054 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2057 return (ctf_set_errno (fp
, ECTF_BADID
));
2059 if (name
!= NULL
&& name
[0] == '\0')
2062 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2063 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2064 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2066 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
2067 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
2069 if (vlen
== CTF_MAX_VLEN
)
2070 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2074 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2075 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2077 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
2078 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2082 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
2083 (malign
= ctf_type_align (fp
, type
)) < 0)
2085 /* The unimplemented type, and any type that resolves to it, has no size
2086 and no alignment: it can correspond to any number of compiler-inserted
2087 types. We allow incomplete types through since they are routinely
2088 added to the ends of structures, and can even be added elsewhere in
2089 structures by the deduplicator. They are assumed to be zero-size with
2090 no alignment: this is often wrong, but problems can be avoided in this
2091 case by explicitly specifying the size of the structure via the _sized
2092 functions. The deduplicator always does this. */
2096 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
2097 ctf_set_errno (fp
, 0);
2098 else if (ctf_errno (fp
) == ECTF_INCOMPLETE
)
2101 return -1; /* errno is set for us. */
2104 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2105 return (ctf_set_errno (fp
, EAGAIN
));
2107 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2110 return (ctf_set_errno (fp
, EAGAIN
));
2114 dmd
->dmd_type
= type
;
2115 dmd
->dmd_value
= -1;
2117 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
2119 if (bit_offset
== (unsigned long) - 1)
2121 /* Natural alignment. */
2123 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
2124 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
2125 size_t off
= lmd
->dmd_offset
;
2127 ctf_encoding_t linfo
;
2130 /* Propagate any error from ctf_type_resolve. If the last member was
2131 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
2132 cannot insert right after such a member without explicit offset
2133 specification, because its alignment and size is not known. */
2134 if (ltype
== CTF_ERR
)
2137 return -1; /* errno is set for us. */
2142 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2143 _("ctf_add_member_offset: cannot add member %s of "
2144 "incomplete type %lx to struct %lx without "
2145 "specifying explicit offset\n"),
2146 name
? name
: _("(unnamed member)"), type
, souid
);
2147 return (ctf_set_errno (fp
, ECTF_INCOMPLETE
));
2150 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
2151 off
+= linfo
.cte_bits
;
2152 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
2153 off
+= lsize
* CHAR_BIT
;
2154 else if (lsize
== -1 && ctf_errno (fp
) == ECTF_INCOMPLETE
)
2156 ctf_err_warn (fp
, 1, ECTF_INCOMPLETE
,
2157 _("ctf_add_member_offset: cannot add member %s of "
2158 "type %lx to struct %lx without specifying "
2159 "explicit offset after member %s of type %lx, "
2160 "which is an incomplete type\n"),
2161 name
? name
: _("(unnamed member)"), type
, souid
,
2162 lmd
->dmd_name
? lmd
->dmd_name
2163 : _("(unnamed member)"), ltype
);
2164 return -1; /* errno is set for us. */
2167 /* Round up the offset of the end of the last member to
2168 the next byte boundary, convert 'off' to bytes, and
2169 then round it up again to the next multiple of the
2170 alignment required by the new member. Finally,
2171 convert back to bits and store the result in
2172 dmd_offset. Technically we could do more efficient
2173 packing if the new member is a bit-field, but we're
2174 the "compiler" and ANSI says we can do as we choose. */
2176 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
2177 off
= roundup (off
, MAX (malign
, 1));
2178 dmd
->dmd_offset
= off
* CHAR_BIT
;
2179 ssize
= off
+ msize
;
2183 /* Specified offset in bits. */
2185 dmd
->dmd_offset
= bit_offset
;
2186 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2187 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
2192 dmd
->dmd_offset
= 0;
2193 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2194 ssize
= MAX (ssize
, msize
);
2197 if ((size_t) ssize
> CTF_MAX_SIZE
)
2199 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2200 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
2201 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
2204 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
2206 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2207 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2209 fp
->ctf_flags
|= LCTF_DIRTY
;
2214 ctf_add_member_encoded (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2215 ctf_id_t type
, unsigned long bit_offset
,
2216 const ctf_encoding_t encoding
)
2218 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
2219 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2222 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
2223 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
2225 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
2226 return -1; /* errno is set for us. */
2228 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
2232 ctf_add_member (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2235 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
2239 ctf_add_variable (ctf_dict_t
*fp
, const char *name
, ctf_id_t ref
)
2242 ctf_dict_t
*tmp
= fp
;
2244 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2245 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2247 if (ctf_dvd_lookup (fp
, name
) != NULL
)
2248 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2250 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
2251 return -1; /* errno is set for us. */
2253 /* Make sure this type is representable. */
2254 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
2255 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
2258 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
2259 return (ctf_set_errno (fp
, EAGAIN
));
2261 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
2264 return (ctf_set_errno (fp
, EAGAIN
));
2266 dvd
->dvd_type
= ref
;
2267 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
2269 if (ctf_dvd_insert (fp
, dvd
) < 0)
2271 free (dvd
->dvd_name
);
2273 return -1; /* errno is set for us. */
2276 fp
->ctf_flags
|= LCTF_DIRTY
;
2281 ctf_add_funcobjt_sym (ctf_dict_t
*fp
, int is_function
, const char *name
, ctf_id_t id
)
2283 ctf_dict_t
*tmp
= fp
;
2285 ctf_dynhash_t
*h
= is_function
? fp
->ctf_funchash
: fp
->ctf_objthash
;
2287 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2288 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2290 if (ctf_dynhash_lookup (fp
->ctf_objthash
, name
) != NULL
||
2291 ctf_dynhash_lookup (fp
->ctf_funchash
, name
) != NULL
)
2292 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2294 if (ctf_lookup_by_id (&tmp
, id
) == NULL
)
2295 return -1; /* errno is set for us. */
2297 if (is_function
&& ctf_type_kind (fp
, id
) != CTF_K_FUNCTION
)
2298 return (ctf_set_errno (fp
, ECTF_NOTFUNC
));
2300 if ((dupname
= strdup (name
)) == NULL
)
2301 return (ctf_set_errno (fp
, ENOMEM
));
2303 if (ctf_dynhash_insert (h
, dupname
, (void *) (uintptr_t) id
) < 0)
2306 return (ctf_set_errno (fp
, ENOMEM
));
2312 ctf_add_objt_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2314 return (ctf_add_funcobjt_sym (fp
, 0, name
, id
));
2318 ctf_add_func_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2320 return (ctf_add_funcobjt_sym (fp
, 1, name
, id
));
2323 typedef struct ctf_bundle
2325 ctf_dict_t
*ctb_dict
; /* CTF dict handle. */
2326 ctf_id_t ctb_type
; /* CTF type identifier. */
2327 ctf_dtdef_t
*ctb_dtd
; /* CTF dynamic type definition (if any). */
2331 enumcmp (const char *name
, int value
, void *arg
)
2333 ctf_bundle_t
*ctb
= arg
;
2336 if (ctf_enum_value (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &bvalue
) < 0)
2338 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2339 _("conflict due to enum %s iteration error"), name
);
2342 if (value
!= bvalue
)
2344 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2345 _("conflict due to enum value change: %i versus %i"),
2353 enumadd (const char *name
, int value
, void *arg
)
2355 ctf_bundle_t
*ctb
= arg
;
2357 return (ctf_add_enumerator (ctb
->ctb_dict
, ctb
->ctb_type
,
2362 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
2365 ctf_bundle_t
*ctb
= arg
;
2368 /* Don't check nameless members (e.g. anonymous structs/unions) against each
2373 if (ctf_member_info (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &ctm
) < 0)
2375 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2376 _("conflict due to struct member %s iteration error"),
2380 if (ctm
.ctm_offset
!= offset
)
2382 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2383 _("conflict due to struct member %s offset change: "
2385 name
, ctm
.ctm_offset
, offset
);
2392 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
2394 ctf_bundle_t
*ctb
= arg
;
2398 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2399 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2401 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2404 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2407 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
2408 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
2410 dmd
->dmd_type
= type
;
2411 dmd
->dmd_offset
= offset
;
2412 dmd
->dmd_value
= -1;
2414 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
2416 ctb
->ctb_dict
->ctf_flags
|= LCTF_DIRTY
;
2420 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
2421 to a dynamic destination dictionary. This routine operates recursively by
2422 following the source type's links and embedded member types. If the
2423 destination dict already contains a named type which has the same attributes,
2424 then we succeed and return this type but no changes occur. */
2426 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2427 ctf_dict_t
*proc_tracking_fp
)
2429 ctf_id_t dst_type
= CTF_ERR
;
2430 uint32_t dst_kind
= CTF_K_UNKNOWN
;
2431 ctf_dict_t
*tmp_fp
= dst_fp
;
2435 uint32_t kind
, forward_kind
, flag
, vlen
;
2437 const ctf_type_t
*src_tp
, *dst_tp
;
2438 ctf_bundle_t src
, dst
;
2439 ctf_encoding_t src_en
, dst_en
;
2440 ctf_arinfo_t src_ar
, dst_ar
;
2444 ctf_id_t orig_src_type
= src_type
;
2446 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
2447 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
2449 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
2450 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2452 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
2453 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
2454 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
2456 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
2457 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
2458 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
2459 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
2461 /* If this is a type we are currently in the middle of adding, hand it
2462 straight back. (This lets us handle self-referential structures without
2463 considering forwards and empty structures the same as their completed
2466 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
2470 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
2471 (void *) (uintptr_t) src_type
))
2474 /* If this type has already been added from this dictionary, and is the
2475 same kind and (if a struct or union) has the same number of members,
2476 hand it straight back. */
2478 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
2480 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
2481 || kind
== CTF_K_ENUM
)
2483 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
2484 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
2492 forward_kind
= kind
;
2493 if (kind
== CTF_K_FORWARD
)
2494 forward_kind
= src_tp
->ctt_type
;
2496 /* If the source type has a name and is a root type (visible at the top-level
2497 scope), lookup the name in the destination dictionary and verify that it is
2498 of the same kind before we do anything else. */
2500 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
2501 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
2504 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
2507 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
2508 unless dst_type is a forward declaration and src_type is a struct,
2509 union, or enum (i.e. the definition of the previous forward decl).
2511 We also allow addition in the opposite order (addition of a forward when a
2512 struct, union, or enum already exists), which is a NOP and returns the
2513 already-present struct, union, or enum. */
2515 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
2517 if (kind
== CTF_K_FORWARD
2518 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
2519 || dst_kind
== CTF_K_UNION
))
2521 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2525 if (dst_kind
!= CTF_K_FORWARD
2526 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
2527 && kind
!= CTF_K_UNION
))
2529 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2530 _("ctf_add_type: conflict for type %s: "
2531 "kinds differ, new: %i; old (ID %lx): %i"),
2532 name
, kind
, dst_type
, dst_kind
);
2533 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2537 /* We take special action for an integer, float, or slice since it is
2538 described not only by its name but also its encoding. For integers,
2539 bit-fields exploit this degeneracy. */
2541 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
2543 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
2544 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2546 if (dst_type
!= CTF_ERR
)
2548 ctf_dict_t
*fp
= dst_fp
;
2550 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
2553 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
2554 return CTF_ERR
; /* errno set for us. */
2556 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
2558 /* The type that we found in the hash is also root-visible. If
2559 the two types match then use the existing one; otherwise,
2560 declare a conflict. Note: slices are not certain to match
2561 even if there is no conflict: we must check the contained type
2564 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2566 if (kind
!= CTF_K_SLICE
)
2568 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2574 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2579 /* We found a non-root-visible type in the hash. If its encoding
2580 is the same, we can reuse it, unless it is a slice. */
2582 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2584 if (kind
!= CTF_K_SLICE
)
2586 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2594 src
.ctb_dict
= src_fp
;
2595 src
.ctb_type
= src_type
;
2598 dst
.ctb_dict
= dst_fp
;
2599 dst
.ctb_type
= dst_type
;
2602 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
2603 a new type with the same properties as src_type to dst_fp. If dst_type is
2604 not CTF_ERR, then we verify that dst_type has the same attributes as
2605 src_type. We recurse for embedded references. Before we start, we note
2606 that we are processing this type, to prevent infinite recursion: we do not
2607 re-process any type that appears in this list. The list is emptied
2608 wholesale at the end of processing everything in this recursive stack. */
2610 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
2611 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
2612 return ctf_set_errno (dst_fp
, ENOMEM
);
2617 /* If we found a match we will have either returned it or declared a
2619 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
2623 /* If we found a match we will have either returned it or declared a
2625 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
2629 /* We have checked for conflicting encodings: now try to add the
2631 src_type
= ctf_type_reference (src_fp
, src_type
);
2632 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2635 if (src_type
== CTF_ERR
)
2636 return CTF_ERR
; /* errno is set for us. */
2638 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
2642 case CTF_K_VOLATILE
:
2644 case CTF_K_RESTRICT
:
2645 src_type
= ctf_type_reference (src_fp
, src_type
);
2646 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2649 if (src_type
== CTF_ERR
)
2650 return CTF_ERR
; /* errno is set for us. */
2652 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
2656 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
2657 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2659 src_ar
.ctr_contents
=
2660 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
2662 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
2665 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
2667 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
2668 return CTF_ERR
; /* errno is set for us. */
2670 if (dst_type
!= CTF_ERR
)
2672 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
2673 return CTF_ERR
; /* errno is set for us. */
2675 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
2677 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2678 _("conflict for type %s against ID %lx: array info "
2679 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
2680 name
, dst_type
, src_ar
.ctr_contents
,
2681 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
2682 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
2684 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2688 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
2691 case CTF_K_FUNCTION
:
2692 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
2698 if (ctc
.ctc_return
== CTF_ERR
)
2699 return CTF_ERR
; /* errno is set for us. */
2701 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
2713 /* Technically to match a struct or union we need to check both
2714 ways (src members vs. dst, dst members vs. src) but we make
2715 this more optimal by only checking src vs. dst and comparing
2716 the total size of the structure (which we must do anyway)
2717 which covers the possibility of dst members not in src.
2718 This optimization can be defeated for unions, but is so
2719 pathological as to render it irrelevant for our purposes. */
2721 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2722 && dst_kind
!= CTF_K_FORWARD
)
2724 if (ctf_type_size (src_fp
, src_type
) !=
2725 ctf_type_size (dst_fp
, dst_type
))
2727 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2728 _("conflict for type %s against ID %lx: union "
2729 "size differs, old %li, new %li"), name
,
2730 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
2731 (long) ctf_type_size (dst_fp
, dst_type
));
2732 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2735 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
2737 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2738 _("conflict for type %s against ID %lx: members "
2739 "differ, see above"), name
, dst_type
);
2740 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2746 /* Unlike the other cases, copying structs and unions is done
2747 manually so as to avoid repeated lookups in ctf_add_member
2748 and to ensure the exact same member offsets as in src_type. */
2750 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2751 if (dst_type
== CTF_ERR
)
2752 return CTF_ERR
; /* errno is set for us. */
2754 dst
.ctb_type
= dst_type
;
2757 /* Pre-emptively add this struct to the type mapping so that
2758 structures that refer to themselves work. */
2759 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2761 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2762 errs
++; /* Increment errs and fail at bottom of case. */
2764 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2765 return CTF_ERR
; /* errno is set for us. */
2767 size
= (size_t) ssize
;
2768 if (size
> CTF_MAX_SIZE
)
2770 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2771 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2772 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2775 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2777 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2779 /* Make a final pass through the members changing each dmd_type (a
2780 src_fp type) to an equivalent type in dst_fp. We pass through all
2781 members, leaving any that fail set to CTF_ERR, unless they fail
2782 because they are marking a member of type not representable in this
2783 version of CTF, in which case we just want to silently omit them:
2784 no consumer can do anything with them anyway. */
2785 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2786 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2788 ctf_dict_t
*dst
= dst_fp
;
2791 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2794 if ((dmd
->dmd_type
=
2795 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2796 proc_tracking_fp
)) == CTF_ERR
)
2798 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2803 dmd
->dmd_type
= memb_type
;
2807 return CTF_ERR
; /* errno is set for us. */
2812 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2813 && dst_kind
!= CTF_K_FORWARD
)
2815 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2816 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2818 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2819 _("conflict for enum %s against ID %lx: members "
2820 "differ, see above"), name
, dst_type
);
2821 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2826 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2827 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2828 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2829 return CTF_ERR
; /* errno is set for us */
2834 if (dst_type
== CTF_ERR
)
2835 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2839 src_type
= ctf_type_reference (src_fp
, src_type
);
2840 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2843 if (src_type
== CTF_ERR
)
2844 return CTF_ERR
; /* errno is set for us. */
2846 /* If dst_type is not CTF_ERR at this point, we should check if
2847 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2848 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2849 that vary based on things like if 32-bit then pid_t is int otherwise
2850 long. We therefore omit this check and assume that if the identically
2851 named typedef already exists in dst_fp, it is correct or
2854 if (dst_type
== CTF_ERR
)
2855 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2860 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2863 if (dst_type
!= CTF_ERR
)
2864 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2869 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
2873 if (!src_fp
->ctf_add_processing
)
2874 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2875 ctf_hash_eq_integer
,
2878 /* We store the hash on the source, because it contains only source type IDs:
2879 but callers will invariably expect errors to appear on the dest. */
2880 if (!src_fp
->ctf_add_processing
)
2881 return (ctf_set_errno (dst_fp
, ENOMEM
));
2883 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2884 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2889 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2891 ctf_gzwrite (ctf_dict_t
*fp
, gzFile fd
)
2893 const unsigned char *buf
;
2897 resid
= sizeof (ctf_header_t
);
2898 buf
= (unsigned char *) fp
->ctf_header
;
2901 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2902 return (ctf_set_errno (fp
, errno
));
2907 resid
= fp
->ctf_size
;
2911 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2912 return (ctf_set_errno (fp
, errno
));
2920 /* Compress the specified CTF data stream and write it to the specified file
2923 ctf_compress_write (ctf_dict_t
*fp
, int fd
)
2928 ctf_header_t
*hp
= &h
;
2929 ssize_t header_len
= sizeof (ctf_header_t
);
2930 ssize_t compress_len
;
2935 if (ctf_serialize (fp
) < 0)
2936 return -1; /* errno is set for us. */
2938 memcpy (hp
, fp
->ctf_header
, header_len
);
2939 hp
->cth_flags
|= CTF_F_COMPRESS
;
2940 compress_len
= compressBound (fp
->ctf_size
);
2942 if ((buf
= malloc (compress_len
)) == NULL
)
2944 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
2945 (unsigned long) compress_len
);
2946 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2949 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2950 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2952 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2953 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
2957 while (header_len
> 0)
2959 if ((len
= write (fd
, hp
, header_len
)) < 0)
2961 err
= ctf_set_errno (fp
, errno
);
2962 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing header"));
2970 while (compress_len
> 0)
2972 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2974 err
= ctf_set_errno (fp
, errno
);
2975 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing"));
2978 compress_len
-= len
;
2987 /* Optionally compress the specified CTF data stream and return it as a new
2988 dynamically-allocated string. */
2990 ctf_write_mem (ctf_dict_t
*fp
, size_t *size
, size_t threshold
)
2995 ssize_t header_len
= sizeof (ctf_header_t
);
2996 ssize_t compress_len
;
2999 if (ctf_serialize (fp
) < 0)
3000 return NULL
; /* errno is set for us. */
3002 compress_len
= compressBound (fp
->ctf_size
);
3003 if (fp
->ctf_size
< threshold
)
3004 compress_len
= fp
->ctf_size
;
3005 if ((buf
= malloc (compress_len
3006 + sizeof (struct ctf_header
))) == NULL
)
3008 ctf_set_errno (fp
, ENOMEM
);
3009 ctf_err_warn (fp
, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
3010 (unsigned long) (compress_len
+ sizeof (struct ctf_header
)));
3014 hp
= (ctf_header_t
*) buf
;
3015 memcpy (hp
, fp
->ctf_header
, header_len
);
3016 bp
= buf
+ sizeof (struct ctf_header
);
3017 *size
= sizeof (struct ctf_header
);
3019 if (fp
->ctf_size
< threshold
)
3021 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
3022 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
3023 *size
+= fp
->ctf_size
;
3027 hp
->cth_flags
|= CTF_F_COMPRESS
;
3028 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
3029 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
3031 ctf_set_errno (fp
, ECTF_COMPRESS
);
3032 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3036 *size
+= compress_len
;
3041 /* Write the uncompressed CTF data stream to the specified file descriptor. */
3043 ctf_write (ctf_dict_t
*fp
, int fd
)
3045 const unsigned char *buf
;
3049 if (ctf_serialize (fp
) < 0)
3050 return -1; /* errno is set for us. */
3052 resid
= sizeof (ctf_header_t
);
3053 buf
= (unsigned char *) fp
->ctf_header
;
3056 if ((len
= write (fd
, buf
, resid
)) <= 0)
3058 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing header"));
3059 return (ctf_set_errno (fp
, errno
));
3065 resid
= fp
->ctf_size
;
3069 if ((len
= write (fd
, buf
, resid
)) <= 0)
3071 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing"));
3072 return (ctf_set_errno (fp
, errno
));