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 ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_ARRAY
, &dtd
)) == CTF_ERR
)
1694 return CTF_ERR
; /* errno is set for us. */
1696 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ARRAY
, flag
, 0);
1697 dtd
->dtd_data
.ctt_size
= 0;
1698 dtd
->dtd_u
.dtu_arr
= *arp
;
1704 ctf_set_array (ctf_dict_t
*fp
, ctf_id_t type
, const ctf_arinfo_t
*arp
)
1706 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
1708 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1709 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1712 || LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
) != CTF_K_ARRAY
)
1713 return (ctf_set_errno (fp
, ECTF_BADID
));
1715 fp
->ctf_flags
|= LCTF_DIRTY
;
1716 dtd
->dtd_u
.dtu_arr
= *arp
;
1722 ctf_add_function (ctf_dict_t
*fp
, uint32_t flag
,
1723 const ctf_funcinfo_t
*ctc
, const ctf_id_t
*argv
)
1728 uint32_t *vdat
= NULL
;
1729 ctf_dict_t
*tmp
= fp
;
1732 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1733 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1735 if (ctc
== NULL
|| (ctc
->ctc_flags
& ~CTF_FUNC_VARARG
) != 0
1736 || (ctc
->ctc_argc
!= 0 && argv
== NULL
))
1737 return (ctf_set_errno (fp
, EINVAL
));
1739 vlen
= ctc
->ctc_argc
;
1740 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1741 vlen
++; /* Add trailing zero to indicate varargs (see below). */
1743 if (ctc
->ctc_return
!= 0
1744 && ctf_lookup_by_id (&tmp
, ctc
->ctc_return
) == NULL
)
1745 return CTF_ERR
; /* errno is set for us. */
1747 if (vlen
> CTF_MAX_VLEN
)
1748 return (ctf_set_errno (fp
, EOVERFLOW
));
1750 if (vlen
!= 0 && (vdat
= malloc (sizeof (ctf_id_t
) * vlen
)) == NULL
)
1751 return (ctf_set_errno (fp
, EAGAIN
));
1753 for (i
= 0; i
< ctc
->ctc_argc
; i
++)
1756 if (argv
[i
] != 0 && ctf_lookup_by_id (&tmp
, argv
[i
]) == NULL
)
1759 return CTF_ERR
; /* errno is set for us. */
1761 vdat
[i
] = (uint32_t) argv
[i
];
1764 if ((type
= ctf_add_generic (fp
, flag
, NULL
, CTF_K_FUNCTION
,
1768 return CTF_ERR
; /* errno is set for us. */
1771 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FUNCTION
, flag
, vlen
);
1772 dtd
->dtd_data
.ctt_type
= (uint32_t) ctc
->ctc_return
;
1774 if (ctc
->ctc_flags
& CTF_FUNC_VARARG
)
1775 vdat
[vlen
- 1] = 0; /* Add trailing zero to indicate varargs. */
1776 dtd
->dtd_u
.dtu_argv
= vdat
;
1782 ctf_add_struct_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1788 /* Promote root-visible forwards to structs. */
1790 type
= ctf_lookup_by_rawname (fp
, CTF_K_STRUCT
, name
);
1792 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1793 dtd
= ctf_dtd_lookup (fp
, type
);
1794 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_STRUCT
,
1796 return CTF_ERR
; /* errno is set for us. */
1798 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_STRUCT
, flag
, 0);
1800 if (size
> CTF_MAX_SIZE
)
1802 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1803 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1804 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1807 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1813 ctf_add_struct (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1815 return (ctf_add_struct_sized (fp
, flag
, name
, 0));
1819 ctf_add_union_sized (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1825 /* Promote root-visible forwards to unions. */
1827 type
= ctf_lookup_by_rawname (fp
, CTF_K_UNION
, name
);
1829 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1830 dtd
= ctf_dtd_lookup (fp
, type
);
1831 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_UNION
,
1833 return CTF_ERR
; /* errno is set for us */
1835 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_UNION
, flag
, 0);
1837 if (size
> CTF_MAX_SIZE
)
1839 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
1840 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
1841 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
1844 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
1850 ctf_add_union (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1852 return (ctf_add_union_sized (fp
, flag
, name
, 0));
1856 ctf_add_enum (ctf_dict_t
*fp
, uint32_t flag
, const char *name
)
1861 /* Promote root-visible forwards to enums. */
1863 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1865 if (type
!= 0 && ctf_type_kind (fp
, type
) == CTF_K_FORWARD
)
1866 dtd
= ctf_dtd_lookup (fp
, type
);
1867 else if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_ENUM
,
1869 return CTF_ERR
; /* errno is set for us. */
1871 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_ENUM
, flag
, 0);
1872 dtd
->dtd_data
.ctt_size
= fp
->ctf_dmodel
->ctd_int
;
1878 ctf_add_enum_encoded (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1879 const ctf_encoding_t
*ep
)
1883 /* First, create the enum if need be, using most of the same machinery as
1884 ctf_add_enum(), to ensure that we do not allow things past that are not
1885 enums or forwards to them. (This includes other slices: you cannot slice a
1886 slice, which would be a useless thing to do anyway.) */
1889 type
= ctf_lookup_by_rawname (fp
, CTF_K_ENUM
, name
);
1893 if ((ctf_type_kind (fp
, type
) != CTF_K_FORWARD
) &&
1894 (ctf_type_kind_unsliced (fp
, type
) != CTF_K_ENUM
))
1895 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
1897 else if ((type
= ctf_add_enum (fp
, flag
, name
)) == CTF_ERR
)
1898 return CTF_ERR
; /* errno is set for us. */
1900 /* Now attach a suitable slice to it. */
1902 return ctf_add_slice (fp
, flag
, type
, ep
);
1906 ctf_add_forward (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1912 if (!ctf_forwardable_kind (kind
))
1913 return (ctf_set_errno (fp
, ECTF_NOTSUE
));
1915 /* If the type is already defined or exists as a forward tag, just
1916 return the ctf_id_t of the existing definition. */
1919 type
= ctf_lookup_by_rawname (fp
, kind
, name
);
1924 if ((type
= ctf_add_generic (fp
, flag
, name
, kind
, &dtd
)) == CTF_ERR
)
1925 return CTF_ERR
; /* errno is set for us. */
1927 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_FORWARD
, flag
, 0);
1928 dtd
->dtd_data
.ctt_type
= kind
;
1934 ctf_add_typedef (ctf_dict_t
*fp
, uint32_t flag
, const char *name
,
1939 ctf_dict_t
*tmp
= fp
;
1941 if (ref
== CTF_ERR
|| ref
> CTF_MAX_TYPE
)
1942 return (ctf_set_errno (fp
, EINVAL
));
1944 if (ref
!= 0 && ctf_lookup_by_id (&tmp
, ref
) == NULL
)
1945 return CTF_ERR
; /* errno is set for us. */
1947 if ((type
= ctf_add_generic (fp
, flag
, name
, CTF_K_TYPEDEF
,
1949 return CTF_ERR
; /* errno is set for us. */
1951 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (CTF_K_TYPEDEF
, flag
, 0);
1952 dtd
->dtd_data
.ctt_type
= (uint32_t) ref
;
1958 ctf_add_volatile (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1960 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_VOLATILE
));
1964 ctf_add_const (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1966 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_CONST
));
1970 ctf_add_restrict (ctf_dict_t
*fp
, uint32_t flag
, ctf_id_t ref
)
1972 return (ctf_add_reftype (fp
, flag
, ref
, CTF_K_RESTRICT
));
1976 ctf_add_enumerator (ctf_dict_t
*fp
, ctf_id_t enid
, const char *name
,
1979 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, enid
);
1982 uint32_t kind
, vlen
, root
;
1986 return (ctf_set_errno (fp
, EINVAL
));
1988 if (!(fp
->ctf_flags
& LCTF_RDWR
))
1989 return (ctf_set_errno (fp
, ECTF_RDONLY
));
1992 return (ctf_set_errno (fp
, ECTF_BADID
));
1994 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
1995 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
1996 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
1998 if (kind
!= CTF_K_ENUM
)
1999 return (ctf_set_errno (fp
, ECTF_NOTENUM
));
2001 if (vlen
== CTF_MAX_VLEN
)
2002 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2004 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2005 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2007 if (strcmp (dmd
->dmd_name
, name
) == 0)
2008 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2011 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2012 return (ctf_set_errno (fp
, EAGAIN
));
2014 if ((s
= strdup (name
)) == NULL
)
2017 return (ctf_set_errno (fp
, EAGAIN
));
2021 dmd
->dmd_type
= CTF_ERR
;
2022 dmd
->dmd_offset
= 0;
2023 dmd
->dmd_value
= value
;
2025 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2026 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2028 fp
->ctf_flags
|= LCTF_DIRTY
;
2034 ctf_add_member_offset (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2035 ctf_id_t type
, unsigned long bit_offset
)
2037 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, souid
);
2040 ssize_t msize
, malign
, ssize
;
2041 uint32_t kind
, vlen
, root
;
2044 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2045 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2048 return (ctf_set_errno (fp
, ECTF_BADID
));
2050 if (name
!= NULL
&& name
[0] == '\0')
2053 kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2054 root
= LCTF_INFO_ISROOT (fp
, dtd
->dtd_data
.ctt_info
);
2055 vlen
= LCTF_INFO_VLEN (fp
, dtd
->dtd_data
.ctt_info
);
2057 if (kind
!= CTF_K_STRUCT
&& kind
!= CTF_K_UNION
)
2058 return (ctf_set_errno (fp
, ECTF_NOTSOU
));
2060 if (vlen
== CTF_MAX_VLEN
)
2061 return (ctf_set_errno (fp
, ECTF_DTFULL
));
2065 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2066 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2068 if (dmd
->dmd_name
!= NULL
&& strcmp (dmd
->dmd_name
, name
) == 0)
2069 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2073 if ((msize
= ctf_type_size (fp
, type
)) < 0 ||
2074 (malign
= ctf_type_align (fp
, type
)) < 0)
2076 /* The unimplemented type, and any type that resolves to it, has no size
2077 and no alignment: it can correspond to any number of compiler-inserted
2080 if (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
)
2084 ctf_set_errno (fp
, 0);
2087 return -1; /* errno is set for us. */
2090 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2091 return (ctf_set_errno (fp
, EAGAIN
));
2093 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2096 return (ctf_set_errno (fp
, EAGAIN
));
2100 dmd
->dmd_type
= type
;
2101 dmd
->dmd_value
= -1;
2103 if (kind
== CTF_K_STRUCT
&& vlen
!= 0)
2105 if (bit_offset
== (unsigned long) - 1)
2107 /* Natural alignment. */
2109 ctf_dmdef_t
*lmd
= ctf_list_prev (&dtd
->dtd_u
.dtu_members
);
2110 ctf_id_t ltype
= ctf_type_resolve (fp
, lmd
->dmd_type
);
2111 size_t off
= lmd
->dmd_offset
;
2113 ctf_encoding_t linfo
;
2116 /* Propagate any error from ctf_type_resolve. If the last member was
2117 of unimplemented type, this may be -ECTF_NONREPRESENTABLE: we
2118 cannot insert right after such a member without explicit offset
2119 specification, because its alignment and size is not known. */
2120 if (ltype
== CTF_ERR
)
2123 return -1; /* errno is set for us. */
2126 if (ctf_type_encoding (fp
, ltype
, &linfo
) == 0)
2127 off
+= linfo
.cte_bits
;
2128 else if ((lsize
= ctf_type_size (fp
, ltype
)) > 0)
2129 off
+= lsize
* CHAR_BIT
;
2131 /* Round up the offset of the end of the last member to
2132 the next byte boundary, convert 'off' to bytes, and
2133 then round it up again to the next multiple of the
2134 alignment required by the new member. Finally,
2135 convert back to bits and store the result in
2136 dmd_offset. Technically we could do more efficient
2137 packing if the new member is a bit-field, but we're
2138 the "compiler" and ANSI says we can do as we choose. */
2140 off
= roundup (off
, CHAR_BIT
) / CHAR_BIT
;
2141 off
= roundup (off
, MAX (malign
, 1));
2142 dmd
->dmd_offset
= off
* CHAR_BIT
;
2143 ssize
= off
+ msize
;
2147 /* Specified offset in bits. */
2149 dmd
->dmd_offset
= bit_offset
;
2150 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2151 ssize
= MAX (ssize
, ((signed) bit_offset
/ CHAR_BIT
) + msize
);
2156 dmd
->dmd_offset
= 0;
2157 ssize
= ctf_get_ctt_size (fp
, &dtd
->dtd_data
, NULL
, NULL
);
2158 ssize
= MAX (ssize
, msize
);
2161 if ((size_t) ssize
> CTF_MAX_SIZE
)
2163 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2164 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (ssize
);
2165 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (ssize
);
2168 dtd
->dtd_data
.ctt_size
= (uint32_t) ssize
;
2170 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, root
, vlen
+ 1);
2171 ctf_list_append (&dtd
->dtd_u
.dtu_members
, dmd
);
2173 fp
->ctf_flags
|= LCTF_DIRTY
;
2178 ctf_add_member_encoded (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2179 ctf_id_t type
, unsigned long bit_offset
,
2180 const ctf_encoding_t encoding
)
2182 ctf_dtdef_t
*dtd
= ctf_dtd_lookup (fp
, type
);
2183 int kind
= LCTF_INFO_KIND (fp
, dtd
->dtd_data
.ctt_info
);
2186 if ((kind
!= CTF_K_INTEGER
) && (kind
!= CTF_K_FLOAT
) && (kind
!= CTF_K_ENUM
))
2187 return (ctf_set_errno (fp
, ECTF_NOTINTFP
));
2189 if ((type
= ctf_add_slice (fp
, CTF_ADD_NONROOT
, otype
, &encoding
)) == CTF_ERR
)
2190 return -1; /* errno is set for us. */
2192 return ctf_add_member_offset (fp
, souid
, name
, type
, bit_offset
);
2196 ctf_add_member (ctf_dict_t
*fp
, ctf_id_t souid
, const char *name
,
2199 return ctf_add_member_offset (fp
, souid
, name
, type
, (unsigned long) - 1);
2203 ctf_add_variable (ctf_dict_t
*fp
, const char *name
, ctf_id_t ref
)
2206 ctf_dict_t
*tmp
= fp
;
2208 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2209 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2211 if (ctf_dvd_lookup (fp
, name
) != NULL
)
2212 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2214 if (ctf_lookup_by_id (&tmp
, ref
) == NULL
)
2215 return -1; /* errno is set for us. */
2217 /* Make sure this type is representable. */
2218 if ((ctf_type_resolve (fp
, ref
) == CTF_ERR
)
2219 && (ctf_errno (fp
) == ECTF_NONREPRESENTABLE
))
2222 if ((dvd
= malloc (sizeof (ctf_dvdef_t
))) == NULL
)
2223 return (ctf_set_errno (fp
, EAGAIN
));
2225 if (name
!= NULL
&& (dvd
->dvd_name
= strdup (name
)) == NULL
)
2228 return (ctf_set_errno (fp
, EAGAIN
));
2230 dvd
->dvd_type
= ref
;
2231 dvd
->dvd_snapshots
= fp
->ctf_snapshots
;
2233 if (ctf_dvd_insert (fp
, dvd
) < 0)
2235 free (dvd
->dvd_name
);
2237 return -1; /* errno is set for us. */
2240 fp
->ctf_flags
|= LCTF_DIRTY
;
2245 ctf_add_funcobjt_sym (ctf_dict_t
*fp
, int is_function
, const char *name
, ctf_id_t id
)
2247 ctf_dict_t
*tmp
= fp
;
2249 ctf_dynhash_t
*h
= is_function
? fp
->ctf_funchash
: fp
->ctf_objthash
;
2251 if (!(fp
->ctf_flags
& LCTF_RDWR
))
2252 return (ctf_set_errno (fp
, ECTF_RDONLY
));
2254 if (ctf_dynhash_lookup (fp
->ctf_objthash
, name
) != NULL
||
2255 ctf_dynhash_lookup (fp
->ctf_funchash
, name
) != NULL
)
2256 return (ctf_set_errno (fp
, ECTF_DUPLICATE
));
2258 if (ctf_lookup_by_id (&tmp
, id
) == NULL
)
2259 return -1; /* errno is set for us. */
2261 if (is_function
&& ctf_type_kind (fp
, id
) != CTF_K_FUNCTION
)
2262 return (ctf_set_errno (fp
, ECTF_NOTFUNC
));
2264 if ((dupname
= strdup (name
)) == NULL
)
2265 return (ctf_set_errno (fp
, ENOMEM
));
2267 if (ctf_dynhash_insert (h
, dupname
, (void *) (uintptr_t) id
) < 0)
2270 return (ctf_set_errno (fp
, ENOMEM
));
2276 ctf_add_objt_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2278 return (ctf_add_funcobjt_sym (fp
, 0, name
, id
));
2282 ctf_add_func_sym (ctf_dict_t
*fp
, const char *name
, ctf_id_t id
)
2284 return (ctf_add_funcobjt_sym (fp
, 1, name
, id
));
2287 typedef struct ctf_bundle
2289 ctf_dict_t
*ctb_dict
; /* CTF dict handle. */
2290 ctf_id_t ctb_type
; /* CTF type identifier. */
2291 ctf_dtdef_t
*ctb_dtd
; /* CTF dynamic type definition (if any). */
2295 enumcmp (const char *name
, int value
, void *arg
)
2297 ctf_bundle_t
*ctb
= arg
;
2300 if (ctf_enum_value (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &bvalue
) < 0)
2302 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2303 _("conflict due to enum %s iteration error"), name
);
2306 if (value
!= bvalue
)
2308 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2309 _("conflict due to enum value change: %i versus %i"),
2317 enumadd (const char *name
, int value
, void *arg
)
2319 ctf_bundle_t
*ctb
= arg
;
2321 return (ctf_add_enumerator (ctb
->ctb_dict
, ctb
->ctb_type
,
2326 membcmp (const char *name
, ctf_id_t type _libctf_unused_
, unsigned long offset
,
2329 ctf_bundle_t
*ctb
= arg
;
2332 /* Don't check nameless members (e.g. anonymous structs/unions) against each
2337 if (ctf_member_info (ctb
->ctb_dict
, ctb
->ctb_type
, name
, &ctm
) < 0)
2339 ctf_err_warn (ctb
->ctb_dict
, 0, 0,
2340 _("conflict due to struct member %s iteration error"),
2344 if (ctm
.ctm_offset
!= offset
)
2346 ctf_err_warn (ctb
->ctb_dict
, 1, ECTF_CONFLICT
,
2347 _("conflict due to struct member %s offset change: "
2349 name
, ctm
.ctm_offset
, offset
);
2356 membadd (const char *name
, ctf_id_t type
, unsigned long offset
, void *arg
)
2358 ctf_bundle_t
*ctb
= arg
;
2362 if ((dmd
= malloc (sizeof (ctf_dmdef_t
))) == NULL
)
2363 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2365 if (name
!= NULL
&& (s
= strdup (name
)) == NULL
)
2368 return (ctf_set_errno (ctb
->ctb_dict
, EAGAIN
));
2371 /* For now, dmd_type is copied as the src_fp's type; it is reset to an
2372 equivalent dst_fp type by a final loop in ctf_add_type(), below. */
2374 dmd
->dmd_type
= type
;
2375 dmd
->dmd_offset
= offset
;
2376 dmd
->dmd_value
= -1;
2378 ctf_list_append (&ctb
->ctb_dtd
->dtd_u
.dtu_members
, dmd
);
2380 ctb
->ctb_dict
->ctf_flags
|= LCTF_DIRTY
;
2384 /* The ctf_add_type routine is used to copy a type from a source CTF dictionary
2385 to a dynamic destination dictionary. This routine operates recursively by
2386 following the source type's links and embedded member types. If the
2387 destination dict already contains a named type which has the same attributes,
2388 then we succeed and return this type but no changes occur. */
2390 ctf_add_type_internal (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
,
2391 ctf_dict_t
*proc_tracking_fp
)
2393 ctf_id_t dst_type
= CTF_ERR
;
2394 uint32_t dst_kind
= CTF_K_UNKNOWN
;
2395 ctf_dict_t
*tmp_fp
= dst_fp
;
2399 uint32_t kind
, forward_kind
, flag
, vlen
;
2401 const ctf_type_t
*src_tp
, *dst_tp
;
2402 ctf_bundle_t src
, dst
;
2403 ctf_encoding_t src_en
, dst_en
;
2404 ctf_arinfo_t src_ar
, dst_ar
;
2408 ctf_id_t orig_src_type
= src_type
;
2410 if (!(dst_fp
->ctf_flags
& LCTF_RDWR
))
2411 return (ctf_set_errno (dst_fp
, ECTF_RDONLY
));
2413 if ((src_tp
= ctf_lookup_by_id (&src_fp
, src_type
)) == NULL
)
2414 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2416 if ((ctf_type_resolve (src_fp
, src_type
) == CTF_ERR
)
2417 && (ctf_errno (src_fp
) == ECTF_NONREPRESENTABLE
))
2418 return (ctf_set_errno (dst_fp
, ECTF_NONREPRESENTABLE
));
2420 name
= ctf_strptr (src_fp
, src_tp
->ctt_name
);
2421 kind
= LCTF_INFO_KIND (src_fp
, src_tp
->ctt_info
);
2422 flag
= LCTF_INFO_ISROOT (src_fp
, src_tp
->ctt_info
);
2423 vlen
= LCTF_INFO_VLEN (src_fp
, src_tp
->ctt_info
);
2425 /* If this is a type we are currently in the middle of adding, hand it
2426 straight back. (This lets us handle self-referential structures without
2427 considering forwards and empty structures the same as their completed
2430 tmp
= ctf_type_mapping (src_fp
, src_type
, &tmp_fp
);
2434 if (ctf_dynhash_lookup (proc_tracking_fp
->ctf_add_processing
,
2435 (void *) (uintptr_t) src_type
))
2438 /* If this type has already been added from this dictionary, and is the
2439 same kind and (if a struct or union) has the same number of members,
2440 hand it straight back. */
2442 if (ctf_type_kind_unsliced (tmp_fp
, tmp
) == (int) kind
)
2444 if (kind
== CTF_K_STRUCT
|| kind
== CTF_K_UNION
2445 || kind
== CTF_K_ENUM
)
2447 if ((dst_tp
= ctf_lookup_by_id (&tmp_fp
, dst_type
)) != NULL
)
2448 if (vlen
== LCTF_INFO_VLEN (tmp_fp
, dst_tp
->ctt_info
))
2456 forward_kind
= kind
;
2457 if (kind
== CTF_K_FORWARD
)
2458 forward_kind
= src_tp
->ctt_type
;
2460 /* If the source type has a name and is a root type (visible at the top-level
2461 scope), lookup the name in the destination dictionary and verify that it is
2462 of the same kind before we do anything else. */
2464 if ((flag
& CTF_ADD_ROOT
) && name
[0] != '\0'
2465 && (tmp
= ctf_lookup_by_rawname (dst_fp
, forward_kind
, name
)) != 0)
2468 dst_kind
= ctf_type_kind_unsliced (dst_fp
, dst_type
);
2471 /* If an identically named dst_type exists, fail with ECTF_CONFLICT
2472 unless dst_type is a forward declaration and src_type is a struct,
2473 union, or enum (i.e. the definition of the previous forward decl).
2475 We also allow addition in the opposite order (addition of a forward when a
2476 struct, union, or enum already exists), which is a NOP and returns the
2477 already-present struct, union, or enum. */
2479 if (dst_type
!= CTF_ERR
&& dst_kind
!= kind
)
2481 if (kind
== CTF_K_FORWARD
2482 && (dst_kind
== CTF_K_ENUM
|| dst_kind
== CTF_K_STRUCT
2483 || dst_kind
== CTF_K_UNION
))
2485 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2489 if (dst_kind
!= CTF_K_FORWARD
2490 || (kind
!= CTF_K_ENUM
&& kind
!= CTF_K_STRUCT
2491 && kind
!= CTF_K_UNION
))
2493 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2494 _("ctf_add_type: conflict for type %s: "
2495 "kinds differ, new: %i; old (ID %lx): %i"),
2496 name
, kind
, dst_type
, dst_kind
);
2497 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2501 /* We take special action for an integer, float, or slice since it is
2502 described not only by its name but also its encoding. For integers,
2503 bit-fields exploit this degeneracy. */
2505 if (kind
== CTF_K_INTEGER
|| kind
== CTF_K_FLOAT
|| kind
== CTF_K_SLICE
)
2507 if (ctf_type_encoding (src_fp
, src_type
, &src_en
) != 0)
2508 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2510 if (dst_type
!= CTF_ERR
)
2512 ctf_dict_t
*fp
= dst_fp
;
2514 if ((dst_tp
= ctf_lookup_by_id (&fp
, dst_type
)) == NULL
)
2517 if (ctf_type_encoding (dst_fp
, dst_type
, &dst_en
) != 0)
2518 return CTF_ERR
; /* errno set for us. */
2520 if (LCTF_INFO_ISROOT (fp
, dst_tp
->ctt_info
) & CTF_ADD_ROOT
)
2522 /* The type that we found in the hash is also root-visible. If
2523 the two types match then use the existing one; otherwise,
2524 declare a conflict. Note: slices are not certain to match
2525 even if there is no conflict: we must check the contained type
2528 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2530 if (kind
!= CTF_K_SLICE
)
2532 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2538 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2543 /* We found a non-root-visible type in the hash. If its encoding
2544 is the same, we can reuse it, unless it is a slice. */
2546 if (memcmp (&src_en
, &dst_en
, sizeof (ctf_encoding_t
)) == 0)
2548 if (kind
!= CTF_K_SLICE
)
2550 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2558 src
.ctb_dict
= src_fp
;
2559 src
.ctb_type
= src_type
;
2562 dst
.ctb_dict
= dst_fp
;
2563 dst
.ctb_type
= dst_type
;
2566 /* Now perform kind-specific processing. If dst_type is CTF_ERR, then we add
2567 a new type with the same properties as src_type to dst_fp. If dst_type is
2568 not CTF_ERR, then we verify that dst_type has the same attributes as
2569 src_type. We recurse for embedded references. Before we start, we note
2570 that we are processing this type, to prevent infinite recursion: we do not
2571 re-process any type that appears in this list. The list is emptied
2572 wholesale at the end of processing everything in this recursive stack. */
2574 if (ctf_dynhash_insert (proc_tracking_fp
->ctf_add_processing
,
2575 (void *) (uintptr_t) src_type
, (void *) 1) < 0)
2576 return ctf_set_errno (dst_fp
, ENOMEM
);
2581 /* If we found a match we will have either returned it or declared a
2583 dst_type
= ctf_add_integer (dst_fp
, flag
, name
, &src_en
);
2587 /* If we found a match we will have either returned it or declared a
2589 dst_type
= ctf_add_float (dst_fp
, flag
, name
, &src_en
);
2593 /* We have checked for conflicting encodings: now try to add the
2595 src_type
= ctf_type_reference (src_fp
, src_type
);
2596 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2599 if (src_type
== CTF_ERR
)
2600 return CTF_ERR
; /* errno is set for us. */
2602 dst_type
= ctf_add_slice (dst_fp
, flag
, src_type
, &src_en
);
2606 case CTF_K_VOLATILE
:
2608 case CTF_K_RESTRICT
:
2609 src_type
= ctf_type_reference (src_fp
, src_type
);
2610 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2613 if (src_type
== CTF_ERR
)
2614 return CTF_ERR
; /* errno is set for us. */
2616 dst_type
= ctf_add_reftype (dst_fp
, flag
, src_type
, kind
);
2620 if (ctf_array_info (src_fp
, src_type
, &src_ar
) != 0)
2621 return (ctf_set_errno (dst_fp
, ctf_errno (src_fp
)));
2623 src_ar
.ctr_contents
=
2624 ctf_add_type_internal (dst_fp
, src_fp
, src_ar
.ctr_contents
,
2626 src_ar
.ctr_index
= ctf_add_type_internal (dst_fp
, src_fp
,
2629 src_ar
.ctr_nelems
= src_ar
.ctr_nelems
;
2631 if (src_ar
.ctr_contents
== CTF_ERR
|| src_ar
.ctr_index
== CTF_ERR
)
2632 return CTF_ERR
; /* errno is set for us. */
2634 if (dst_type
!= CTF_ERR
)
2636 if (ctf_array_info (dst_fp
, dst_type
, &dst_ar
) != 0)
2637 return CTF_ERR
; /* errno is set for us. */
2639 if (memcmp (&src_ar
, &dst_ar
, sizeof (ctf_arinfo_t
)))
2641 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2642 _("conflict for type %s against ID %lx: array info "
2643 "differs, old %lx/%lx/%x; new: %lx/%lx/%x"),
2644 name
, dst_type
, src_ar
.ctr_contents
,
2645 src_ar
.ctr_index
, src_ar
.ctr_nelems
,
2646 dst_ar
.ctr_contents
, dst_ar
.ctr_index
,
2648 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2652 dst_type
= ctf_add_array (dst_fp
, flag
, &src_ar
);
2655 case CTF_K_FUNCTION
:
2656 ctc
.ctc_return
= ctf_add_type_internal (dst_fp
, src_fp
,
2662 if (ctc
.ctc_return
== CTF_ERR
)
2663 return CTF_ERR
; /* errno is set for us. */
2665 dst_type
= ctf_add_function (dst_fp
, flag
, &ctc
, NULL
);
2677 /* Technically to match a struct or union we need to check both
2678 ways (src members vs. dst, dst members vs. src) but we make
2679 this more optimal by only checking src vs. dst and comparing
2680 the total size of the structure (which we must do anyway)
2681 which covers the possibility of dst members not in src.
2682 This optimization can be defeated for unions, but is so
2683 pathological as to render it irrelevant for our purposes. */
2685 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2686 && dst_kind
!= CTF_K_FORWARD
)
2688 if (ctf_type_size (src_fp
, src_type
) !=
2689 ctf_type_size (dst_fp
, dst_type
))
2691 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2692 _("conflict for type %s against ID %lx: union "
2693 "size differs, old %li, new %li"), name
,
2694 dst_type
, (long) ctf_type_size (src_fp
, src_type
),
2695 (long) ctf_type_size (dst_fp
, dst_type
));
2696 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2699 if (ctf_member_iter (src_fp
, src_type
, membcmp
, &dst
))
2701 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2702 _("conflict for type %s against ID %lx: members "
2703 "differ, see above"), name
, dst_type
);
2704 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2710 /* Unlike the other cases, copying structs and unions is done
2711 manually so as to avoid repeated lookups in ctf_add_member
2712 and to ensure the exact same member offsets as in src_type. */
2714 dst_type
= ctf_add_generic (dst_fp
, flag
, name
, kind
, &dtd
);
2715 if (dst_type
== CTF_ERR
)
2716 return CTF_ERR
; /* errno is set for us. */
2718 dst
.ctb_type
= dst_type
;
2721 /* Pre-emptively add this struct to the type mapping so that
2722 structures that refer to themselves work. */
2723 ctf_add_type_mapping (src_fp
, src_type
, dst_fp
, dst_type
);
2725 if (ctf_member_iter (src_fp
, src_type
, membadd
, &dst
) != 0)
2726 errs
++; /* Increment errs and fail at bottom of case. */
2728 if ((ssize
= ctf_type_size (src_fp
, src_type
)) < 0)
2729 return CTF_ERR
; /* errno is set for us. */
2731 size
= (size_t) ssize
;
2732 if (size
> CTF_MAX_SIZE
)
2734 dtd
->dtd_data
.ctt_size
= CTF_LSIZE_SENT
;
2735 dtd
->dtd_data
.ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
2736 dtd
->dtd_data
.ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
2739 dtd
->dtd_data
.ctt_size
= (uint32_t) size
;
2741 dtd
->dtd_data
.ctt_info
= CTF_TYPE_INFO (kind
, flag
, vlen
);
2743 /* Make a final pass through the members changing each dmd_type (a
2744 src_fp type) to an equivalent type in dst_fp. We pass through all
2745 members, leaving any that fail set to CTF_ERR, unless they fail
2746 because they are marking a member of type not representable in this
2747 version of CTF, in which case we just want to silently omit them:
2748 no consumer can do anything with them anyway. */
2749 for (dmd
= ctf_list_next (&dtd
->dtd_u
.dtu_members
);
2750 dmd
!= NULL
; dmd
= ctf_list_next (dmd
))
2752 ctf_dict_t
*dst
= dst_fp
;
2755 memb_type
= ctf_type_mapping (src_fp
, dmd
->dmd_type
, &dst
);
2758 if ((dmd
->dmd_type
=
2759 ctf_add_type_internal (dst_fp
, src_fp
, dmd
->dmd_type
,
2760 proc_tracking_fp
)) == CTF_ERR
)
2762 if (ctf_errno (dst_fp
) != ECTF_NONREPRESENTABLE
)
2767 dmd
->dmd_type
= memb_type
;
2771 return CTF_ERR
; /* errno is set for us. */
2776 if (dst_type
!= CTF_ERR
&& kind
!= CTF_K_FORWARD
2777 && dst_kind
!= CTF_K_FORWARD
)
2779 if (ctf_enum_iter (src_fp
, src_type
, enumcmp
, &dst
)
2780 || ctf_enum_iter (dst_fp
, dst_type
, enumcmp
, &src
))
2782 ctf_err_warn (dst_fp
, 1, ECTF_CONFLICT
,
2783 _("conflict for enum %s against ID %lx: members "
2784 "differ, see above"), name
, dst_type
);
2785 return (ctf_set_errno (dst_fp
, ECTF_CONFLICT
));
2790 dst_type
= ctf_add_enum (dst_fp
, flag
, name
);
2791 if ((dst
.ctb_type
= dst_type
) == CTF_ERR
2792 || ctf_enum_iter (src_fp
, src_type
, enumadd
, &dst
))
2793 return CTF_ERR
; /* errno is set for us */
2798 if (dst_type
== CTF_ERR
)
2799 dst_type
= ctf_add_forward (dst_fp
, flag
, name
, forward_kind
);
2803 src_type
= ctf_type_reference (src_fp
, src_type
);
2804 src_type
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
,
2807 if (src_type
== CTF_ERR
)
2808 return CTF_ERR
; /* errno is set for us. */
2810 /* If dst_type is not CTF_ERR at this point, we should check if
2811 ctf_type_reference(dst_fp, dst_type) != src_type and if so fail with
2812 ECTF_CONFLICT. However, this causes problems with bitness typedefs
2813 that vary based on things like if 32-bit then pid_t is int otherwise
2814 long. We therefore omit this check and assume that if the identically
2815 named typedef already exists in dst_fp, it is correct or
2818 if (dst_type
== CTF_ERR
)
2819 dst_type
= ctf_add_typedef (dst_fp
, flag
, name
, src_type
);
2824 return (ctf_set_errno (dst_fp
, ECTF_CORRUPT
));
2827 if (dst_type
!= CTF_ERR
)
2828 ctf_add_type_mapping (src_fp
, orig_src_type
, dst_fp
, dst_type
);
2833 ctf_add_type (ctf_dict_t
*dst_fp
, ctf_dict_t
*src_fp
, ctf_id_t src_type
)
2837 if (!src_fp
->ctf_add_processing
)
2838 src_fp
->ctf_add_processing
= ctf_dynhash_create (ctf_hash_integer
,
2839 ctf_hash_eq_integer
,
2842 /* We store the hash on the source, because it contains only source type IDs:
2843 but callers will invariably expect errors to appear on the dest. */
2844 if (!src_fp
->ctf_add_processing
)
2845 return (ctf_set_errno (dst_fp
, ENOMEM
));
2847 id
= ctf_add_type_internal (dst_fp
, src_fp
, src_type
, src_fp
);
2848 ctf_dynhash_empty (src_fp
->ctf_add_processing
);
2853 /* Write the compressed CTF data stream to the specified gzFile descriptor. */
2855 ctf_gzwrite (ctf_dict_t
*fp
, gzFile fd
)
2857 const unsigned char *buf
;
2861 resid
= sizeof (ctf_header_t
);
2862 buf
= (unsigned char *) fp
->ctf_header
;
2865 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2866 return (ctf_set_errno (fp
, errno
));
2871 resid
= fp
->ctf_size
;
2875 if ((len
= gzwrite (fd
, buf
, resid
)) <= 0)
2876 return (ctf_set_errno (fp
, errno
));
2884 /* Compress the specified CTF data stream and write it to the specified file
2887 ctf_compress_write (ctf_dict_t
*fp
, int fd
)
2892 ctf_header_t
*hp
= &h
;
2893 ssize_t header_len
= sizeof (ctf_header_t
);
2894 ssize_t compress_len
;
2899 if (ctf_serialize (fp
) < 0)
2900 return -1; /* errno is set for us. */
2902 memcpy (hp
, fp
->ctf_header
, header_len
);
2903 hp
->cth_flags
|= CTF_F_COMPRESS
;
2904 compress_len
= compressBound (fp
->ctf_size
);
2906 if ((buf
= malloc (compress_len
)) == NULL
)
2908 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
2909 (unsigned long) compress_len
);
2910 return (ctf_set_errno (fp
, ECTF_ZALLOC
));
2913 if ((rc
= compress (buf
, (uLongf
*) &compress_len
,
2914 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2916 err
= ctf_set_errno (fp
, ECTF_COMPRESS
);
2917 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
2921 while (header_len
> 0)
2923 if ((len
= write (fd
, hp
, header_len
)) < 0)
2925 err
= ctf_set_errno (fp
, errno
);
2926 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing header"));
2934 while (compress_len
> 0)
2936 if ((len
= write (fd
, bp
, compress_len
)) < 0)
2938 err
= ctf_set_errno (fp
, errno
);
2939 ctf_err_warn (fp
, 0, 0, _("ctf_compress_write: error writing"));
2942 compress_len
-= len
;
2951 /* Optionally compress the specified CTF data stream and return it as a new
2952 dynamically-allocated string. */
2954 ctf_write_mem (ctf_dict_t
*fp
, size_t *size
, size_t threshold
)
2959 ssize_t header_len
= sizeof (ctf_header_t
);
2960 ssize_t compress_len
;
2963 if (ctf_serialize (fp
) < 0)
2964 return NULL
; /* errno is set for us. */
2966 compress_len
= compressBound (fp
->ctf_size
);
2967 if (fp
->ctf_size
< threshold
)
2968 compress_len
= fp
->ctf_size
;
2969 if ((buf
= malloc (compress_len
2970 + sizeof (struct ctf_header
))) == NULL
)
2972 ctf_set_errno (fp
, ENOMEM
);
2973 ctf_err_warn (fp
, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
2974 (unsigned long) (compress_len
+ sizeof (struct ctf_header
)));
2978 hp
= (ctf_header_t
*) buf
;
2979 memcpy (hp
, fp
->ctf_header
, header_len
);
2980 bp
= buf
+ sizeof (struct ctf_header
);
2981 *size
= sizeof (struct ctf_header
);
2983 if (fp
->ctf_size
< threshold
)
2985 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
2986 memcpy (bp
, fp
->ctf_buf
, fp
->ctf_size
);
2987 *size
+= fp
->ctf_size
;
2991 hp
->cth_flags
|= CTF_F_COMPRESS
;
2992 if ((rc
= compress (bp
, (uLongf
*) &compress_len
,
2993 fp
->ctf_buf
, fp
->ctf_size
)) != Z_OK
)
2995 ctf_set_errno (fp
, ECTF_COMPRESS
);
2996 ctf_err_warn (fp
, 0, 0, _("zlib deflate err: %s"), zError (rc
));
3000 *size
+= compress_len
;
3005 /* Write the uncompressed CTF data stream to the specified file descriptor. */
3007 ctf_write (ctf_dict_t
*fp
, int fd
)
3009 const unsigned char *buf
;
3013 if (ctf_serialize (fp
) < 0)
3014 return -1; /* errno is set for us. */
3016 resid
= sizeof (ctf_header_t
);
3017 buf
= (unsigned char *) fp
->ctf_header
;
3020 if ((len
= write (fd
, buf
, resid
)) <= 0)
3022 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing header"));
3023 return (ctf_set_errno (fp
, errno
));
3029 resid
= fp
->ctf_size
;
3033 if ((len
= write (fd
, buf
, resid
)) <= 0)
3035 ctf_err_warn (fp
, 0, errno
, _("ctf_write: error writing"));
3036 return (ctf_set_errno (fp
, errno
));