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/>. */
23 #include <sys/types.h>
29 static const ctf_dmodel_t _libctf_models
[] = {
30 {"ILP32", CTF_MODEL_ILP32
, 4, 1, 2, 4, 4},
31 {"LP64", CTF_MODEL_LP64
, 8, 1, 2, 4, 8},
32 {NULL
, 0, 0, 0, 0, 0, 0}
35 const char _CTF_SECTION
[] = ".ctf";
36 const char _CTF_NULLSTR
[] = "";
38 /* Version-sensitive accessors. */
41 get_kind_v1 (uint32_t info
)
43 return (CTF_V1_INFO_KIND (info
));
47 get_root_v1 (uint32_t info
)
49 return (CTF_V1_INFO_ISROOT (info
));
53 get_vlen_v1 (uint32_t info
)
55 return (CTF_V1_INFO_VLEN (info
));
59 get_kind_v2 (uint32_t info
)
61 return (CTF_V2_INFO_KIND (info
));
65 get_root_v2 (uint32_t info
)
67 return (CTF_V2_INFO_ISROOT (info
));
71 get_vlen_v2 (uint32_t info
)
73 return (CTF_V2_INFO_VLEN (info
));
77 get_ctt_size_common (const ctf_dict_t
*fp _libctf_unused_
,
78 const ctf_type_t
*tp _libctf_unused_
,
79 ssize_t
*sizep
, ssize_t
*incrementp
, size_t lsize
,
80 size_t csize
, size_t ctf_type_size
,
81 size_t ctf_stype_size
, size_t ctf_lsize_sent
)
83 ssize_t size
, increment
;
85 if (csize
== ctf_lsize_sent
)
88 increment
= ctf_type_size
;
93 increment
= ctf_stype_size
;
99 *incrementp
= increment
;
105 get_ctt_size_v1 (const ctf_dict_t
*fp
, const ctf_type_t
*tp
,
106 ssize_t
*sizep
, ssize_t
*incrementp
)
108 ctf_type_v1_t
*t1p
= (ctf_type_v1_t
*) tp
;
110 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
111 CTF_TYPE_LSIZE (t1p
), t1p
->ctt_size
,
112 sizeof (ctf_type_v1_t
), sizeof (ctf_stype_v1_t
),
116 /* Return the size that a v1 will be once it is converted to v2. */
119 get_ctt_size_v2_unconverted (const ctf_dict_t
*fp
, const ctf_type_t
*tp
,
120 ssize_t
*sizep
, ssize_t
*incrementp
)
122 ctf_type_v1_t
*t1p
= (ctf_type_v1_t
*) tp
;
124 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
125 CTF_TYPE_LSIZE (t1p
), t1p
->ctt_size
,
126 sizeof (ctf_type_t
), sizeof (ctf_stype_t
),
131 get_ctt_size_v2 (const ctf_dict_t
*fp
, const ctf_type_t
*tp
,
132 ssize_t
*sizep
, ssize_t
*incrementp
)
134 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
135 CTF_TYPE_LSIZE (tp
), tp
->ctt_size
,
136 sizeof (ctf_type_t
), sizeof (ctf_stype_t
),
141 get_vbytes_common (ctf_dict_t
*fp
, unsigned short kind
,
142 ssize_t size _libctf_unused_
, size_t vlen
)
148 return (sizeof (uint32_t));
150 return (sizeof (ctf_slice_t
));
152 return (sizeof (ctf_enum_t
) * vlen
);
162 ctf_set_errno (fp
, ECTF_CORRUPT
);
163 ctf_err_warn (fp
, 0, 0, _("detected invalid CTF kind: %x"), kind
);
169 get_vbytes_v1 (ctf_dict_t
*fp
, unsigned short kind
, ssize_t size
, size_t vlen
)
174 return (sizeof (ctf_array_v1_t
));
176 return (sizeof (unsigned short) * (vlen
+ (vlen
& 1)));
179 if (size
< CTF_LSTRUCT_THRESH_V1
)
180 return (sizeof (ctf_member_v1_t
) * vlen
);
182 return (sizeof (ctf_lmember_v1_t
) * vlen
);
185 return (get_vbytes_common (fp
, kind
, size
, vlen
));
189 get_vbytes_v2 (ctf_dict_t
*fp
, unsigned short kind
, ssize_t size
, size_t vlen
)
194 return (sizeof (ctf_array_t
));
196 return (sizeof (uint32_t) * (vlen
+ (vlen
& 1)));
199 if (size
< CTF_LSTRUCT_THRESH
)
200 return (sizeof (ctf_member_t
) * vlen
);
202 return (sizeof (ctf_lmember_t
) * vlen
);
205 return (get_vbytes_common (fp
, kind
, size
, vlen
));
208 static const ctf_dictops_t ctf_dictops
[] = {
209 {NULL
, NULL
, NULL
, NULL
, NULL
},
211 {get_kind_v1
, get_root_v1
, get_vlen_v1
, get_ctt_size_v1
, get_vbytes_v1
},
212 /* CTF_VERSION_1_UPGRADED_3 */
213 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
215 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
216 /* CTF_VERSION_3, identical to 2: only new type kinds */
217 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
220 /* Initialize the symtab translation table as appropriate for its indexing
221 state. For unindexed symtypetabs, fill each entry with the offset of the CTF
222 type or function data corresponding to each STT_FUNC or STT_OBJECT entry in
223 the symbol table. For indexed symtypetabs, do nothing: the needed
224 initialization for indexed lookups may be quite expensive, so it is done only
225 as needed, when lookups happen. (In particular, the majority of indexed
226 symtypetabs come from the compiler, and all the linker does is iteration over
227 all entries, which doesn't need this initialization.)
229 The SP symbol table section may be NULL if there is no symtab.
231 If init_symtab works on one call, it cannot fail on future calls to the same
232 fp: ctf_symsect_endianness relies on this. */
235 init_symtab (ctf_dict_t
*fp
, const ctf_header_t
*hp
, const ctf_sect_t
*sp
)
237 const unsigned char *symp
;
238 int skip_func_info
= 0;
240 uint32_t *xp
= fp
->ctf_sxlate
;
241 uint32_t *xend
= xp
+ fp
->ctf_nsyms
;
243 uint32_t objtoff
= hp
->cth_objtoff
;
244 uint32_t funcoff
= hp
->cth_funcoff
;
246 /* If the CTF_F_NEWFUNCINFO flag is not set, pretend the func info section
247 is empty: this compiler is too old to emit a function info section we
250 if (!(hp
->cth_flags
& CTF_F_NEWFUNCINFO
))
253 if (hp
->cth_objtidxoff
< hp
->cth_funcidxoff
)
254 fp
->ctf_objtidx_names
= (uint32_t *) (fp
->ctf_buf
+ hp
->cth_objtidxoff
);
255 if (hp
->cth_funcidxoff
< hp
->cth_varoff
&& !skip_func_info
)
256 fp
->ctf_funcidx_names
= (uint32_t *) (fp
->ctf_buf
+ hp
->cth_funcidxoff
);
258 /* Don't bother doing the rest if everything is indexed, or if we don't have a
259 symbol table: we will never use it. */
260 if ((fp
->ctf_objtidx_names
&& fp
->ctf_funcidx_names
) || !sp
|| !sp
->cts_data
)
263 /* The CTF data object and function type sections are ordered to match the
264 relative order of the respective symbol types in the symtab, unless there
265 is an index section, in which case the order is arbitrary and the index
266 gives the mapping. If no type information is available for a symbol table
267 entry, a pad is inserted in the CTF section. As a further optimization,
268 anonymous or undefined symbols are omitted from the CTF data. If an
269 index is available for function symbols but not object symbols, or vice
270 versa, we populate the xslate table for the unindexed symbols only. */
272 for (i
= 0, symp
= sp
->cts_data
; xp
< xend
; xp
++, symp
+= sp
->cts_entsize
,
277 switch (sp
->cts_entsize
)
279 case sizeof (Elf64_Sym
):
281 const Elf64_Sym
*symp64
= (Elf64_Sym
*) (uintptr_t) symp
;
282 ctf_elf64_to_link_sym (fp
, &sym
, symp64
, i
);
285 case sizeof (Elf32_Sym
):
287 const Elf32_Sym
*symp32
= (Elf32_Sym
*) (uintptr_t) symp
;
288 ctf_elf32_to_link_sym (fp
, &sym
, symp32
, i
);
295 /* This call may be led astray if our idea of the symtab's endianness is
296 wrong, but when this is fixed by a call to ctf_symsect_endianness,
297 init_symtab will be called again with the right endianness in
299 if (ctf_symtab_skippable (&sym
))
308 if (fp
->ctf_objtidx_names
|| objtoff
>= hp
->cth_funcoff
)
315 objtoff
+= sizeof (uint32_t);
319 if (fp
->ctf_funcidx_names
|| funcoff
>= hp
->cth_objtidxoff
327 funcoff
+= sizeof (uint32_t);
336 ctf_dprintf ("loaded %lu symtab entries\n", fp
->ctf_nsyms
);
340 /* Reset the CTF base pointer and derive the buf pointer from it, initializing
341 everything in the ctf_dict that depends on the base or buf pointers.
343 The original gap between the buf and base pointers, if any -- the original,
344 unconverted CTF header -- is kept, but its contents are not specified and are
348 ctf_set_base (ctf_dict_t
*fp
, const ctf_header_t
*hp
, unsigned char *base
)
350 fp
->ctf_buf
= base
+ (fp
->ctf_buf
- fp
->ctf_base
);
352 fp
->ctf_vars
= (ctf_varent_t
*) ((const char *) fp
->ctf_buf
+
354 fp
->ctf_nvars
= (hp
->cth_typeoff
- hp
->cth_varoff
) / sizeof (ctf_varent_t
);
356 fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
= (const char *) fp
->ctf_buf
358 fp
->ctf_str
[CTF_STRTAB_0
].cts_len
= hp
->cth_strlen
;
360 /* If we have a parent dict name and label, store the relocated string
361 pointers in the CTF dict for easy access later. */
363 /* Note: before conversion, these will be set to values that will be
364 immediately invalidated by the conversion process, but the conversion
365 process will call ctf_set_base() again to fix things up. */
367 if (hp
->cth_parlabel
!= 0)
368 fp
->ctf_parlabel
= ctf_strptr (fp
, hp
->cth_parlabel
);
369 if (hp
->cth_parname
!= 0)
370 fp
->ctf_parname
= ctf_strptr (fp
, hp
->cth_parname
);
371 if (hp
->cth_cuname
!= 0)
372 fp
->ctf_cuname
= ctf_strptr (fp
, hp
->cth_cuname
);
375 ctf_dprintf ("ctf_set_base: CU name %s\n", fp
->ctf_cuname
);
377 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
379 fp
->ctf_parlabel
? fp
->ctf_parlabel
: "<NULL>");
382 /* Set the version of the CTF file. */
384 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
385 the variable data list associated with each type has been upgraded: the
386 caller must ensure this has been done in advance. */
389 ctf_set_version (ctf_dict_t
*fp
, ctf_header_t
*cth
, int ctf_version
)
391 fp
->ctf_version
= ctf_version
;
392 cth
->cth_version
= ctf_version
;
393 fp
->ctf_dictops
= &ctf_dictops
[ctf_version
];
397 /* Upgrade the header to CTF_VERSION_3. The upgrade is done in-place. */
399 upgrade_header (ctf_header_t
*hp
)
401 ctf_header_v2_t
*oldhp
= (ctf_header_v2_t
*) hp
;
403 hp
->cth_strlen
= oldhp
->cth_strlen
;
404 hp
->cth_stroff
= oldhp
->cth_stroff
;
405 hp
->cth_typeoff
= oldhp
->cth_typeoff
;
406 hp
->cth_varoff
= oldhp
->cth_varoff
;
407 hp
->cth_funcidxoff
= hp
->cth_varoff
; /* No index sections. */
408 hp
->cth_objtidxoff
= hp
->cth_funcidxoff
;
409 hp
->cth_funcoff
= oldhp
->cth_funcoff
;
410 hp
->cth_objtoff
= oldhp
->cth_objtoff
;
411 hp
->cth_lbloff
= oldhp
->cth_lbloff
;
412 hp
->cth_cuname
= 0; /* No CU name. */
415 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3)
418 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
419 not be called before reallocation is complete.
421 Sections not checked here due to nonexistence or nonpopulated state in older
422 formats: objtidx, funcidx.
424 Type kinds not checked here due to nonexistence in older formats:
427 upgrade_types_v1 (ctf_dict_t
*fp
, ctf_header_t
*cth
)
429 const ctf_type_v1_t
*tbuf
;
430 const ctf_type_v1_t
*tend
;
431 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_dynbase
;
434 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
435 const ctf_type_v1_t
*tp
;
438 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
439 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
441 /* Much like init_types(), this is a two-pass process.
443 First, figure out the new type-section size needed. (It is possible,
444 in theory, for it to be less than the old size, but this is very
445 unlikely. It cannot be so small that cth_typeoff ends up of negative
446 size. We validate this with an assertion below.)
448 We must cater not only for changes in vlen and types sizes but also
449 for changes in 'increment', which happen because v2 places some types
450 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
452 for (tp
= tbuf
; tp
< tend
;
453 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
455 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
456 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
458 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
459 vbytes
= get_vbytes_v1 (fp
, kind
, size
, vlen
);
461 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
463 v2bytes
= get_vbytes_v2 (fp
, kind
, size
, vlen
);
465 if ((vbytes
< 0) || (size
< 0))
468 increase
+= v2increment
- increment
; /* May be negative. */
469 increase
+= v2bytes
- vbytes
;
472 /* Allocate enough room for the new buffer, then copy everything but the type
473 section into place, and reset the base accordingly. Leave the version
474 number unchanged, so that LCTF_INFO_* still works on the
475 as-yet-untranslated type info. */
477 if ((ctf_base
= malloc (fp
->ctf_size
+ increase
)) == NULL
)
480 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
481 never use it and it is unconverted. */
483 memcpy (ctf_base
, fp
->ctf_buf
, cth
->cth_typeoff
);
484 memcpy (ctf_base
+ cth
->cth_stroff
+ increase
,
485 fp
->ctf_buf
+ cth
->cth_stroff
, cth
->cth_strlen
);
487 memset (ctf_base
+ cth
->cth_typeoff
, 0, cth
->cth_stroff
- cth
->cth_typeoff
490 cth
->cth_stroff
+= increase
;
491 fp
->ctf_size
+= increase
;
492 assert (cth
->cth_stroff
>= cth
->cth_typeoff
);
493 fp
->ctf_base
= ctf_base
;
494 fp
->ctf_buf
= ctf_base
;
495 fp
->ctf_dynbase
= ctf_base
;
496 ctf_set_base (fp
, cth
, ctf_base
);
498 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
500 /* Iterate through all the types again, upgrading them.
502 Everything that hasn't changed can just be outright memcpy()ed.
503 Things that have changed need field-by-field consideration. */
505 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
506 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
507 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
509 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
510 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
511 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
513 void *vdata
, *v2data
;
515 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
516 vbytes
= get_vbytes_v1 (fp
, kind
, size
, vlen
);
518 t2p
->ctt_name
= tp
->ctt_name
;
519 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
530 t2p
->ctt_type
= tp
->ctt_type
;
539 if ((size_t) size
<= CTF_MAX_SIZE
)
540 t2p
->ctt_size
= size
;
543 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
544 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
549 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
550 v2bytes
= get_vbytes_v2 (fp
, kind
, v2size
, vlen
);
552 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
553 these are not identical (and having them different makes no
554 sense semantically). */
556 assert (size
== v2size
);
558 /* Now the varlen info. */
560 vdata
= (void *) ((uintptr_t) tp
+ increment
);
561 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
567 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
568 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
570 a2p
->cta_contents
= ap
->cta_contents
;
571 a2p
->cta_index
= ap
->cta_index
;
572 a2p
->cta_nelems
= ap
->cta_nelems
;
579 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
580 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
581 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
582 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
585 /* We walk all four pointers forward, but only reference the two
586 that are valid for the given size, to avoid quadruplicating all
589 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
592 if (size
< CTF_LSTRUCT_THRESH_V1
)
594 offset
= m1
->ctm_offset
;
595 tmp
.ctm_name
= m1
->ctm_name
;
596 tmp
.ctm_type
= m1
->ctm_type
;
600 offset
= CTF_LMEM_OFFSET (lm1
);
601 tmp
.ctm_name
= lm1
->ctlm_name
;
602 tmp
.ctm_type
= lm1
->ctlm_type
;
604 if (size
< CTF_LSTRUCT_THRESH
)
606 m2
->ctm_name
= tmp
.ctm_name
;
607 m2
->ctm_type
= tmp
.ctm_type
;
608 m2
->ctm_offset
= offset
;
612 lm2
->ctlm_name
= tmp
.ctm_name
;
613 lm2
->ctlm_type
= tmp
.ctm_type
;
614 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
615 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
623 unsigned short *a1
= (unsigned short *) vdata
;
624 uint32_t *a2
= (uint32_t *) v2data
;
626 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
631 /* Catch out-of-sync get_vbytes_*(). */
632 assert (vbytes
== v2bytes
);
633 memcpy (v2data
, vdata
, vbytes
);
637 /* Verify that the entire region was converted. If not, we are either
638 converting too much, or too little (leading to a buffer overrun either here
639 or at read time, in init_types().) */
641 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== cth
->cth_stroff
);
643 ctf_set_version (fp
, cth
, CTF_VERSION_1_UPGRADED_3
);
649 /* Upgrade from any earlier version. */
651 upgrade_types (ctf_dict_t
*fp
, ctf_header_t
*cth
)
653 switch (cth
->cth_version
)
655 /* v1 requires a full pass and reformatting. */
657 upgrade_types_v1 (fp
, cth
);
659 /* Already-converted v1 is just like later versions except that its
660 parent/child boundary is unchanged (and much lower). */
662 case CTF_VERSION_1_UPGRADED_3
:
663 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
665 /* v2 is just the same as v3 except for new types and sections:
666 no upgrading required. */
667 case CTF_VERSION_2
: ;
673 /* Initialize the type ID translation table with the byte offset of each type,
674 and initialize the hash tables of each named type. Upgrade the type table to
675 the latest supported representation in the process, if needed, and if this
676 recension of libctf supports upgrading. */
679 init_types (ctf_dict_t
*fp
, ctf_header_t
*cth
)
681 const ctf_type_t
*tbuf
;
682 const ctf_type_t
*tend
;
684 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
685 const ctf_type_t
*tp
;
689 /* We determine whether the dict is a child or a parent based on the value of
692 int child
= cth
->cth_parname
!= 0;
693 int nlstructs
= 0, nlunions
= 0;
696 assert (!(fp
->ctf_flags
& LCTF_RDWR
));
698 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
701 if ((err
= upgrade_types (fp
, cth
)) != 0)
702 return err
; /* Upgrade failed. */
705 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
706 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
708 /* We make two passes through the entire type section. In this first
709 pass, we count the number of each type and the total number of types. */
711 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
713 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
714 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
715 ssize_t size
, increment
, vbytes
;
717 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
718 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
723 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
724 so bump that population count too. */
725 if (kind
== CTF_K_FORWARD
)
728 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
734 ctf_dprintf ("CTF dict %p is a child\n", (void *) fp
);
735 fp
->ctf_flags
|= LCTF_CHILD
;
738 ctf_dprintf ("CTF dict %p is a parent\n", (void *) fp
);
740 /* Now that we've counted up the number of each type, we can allocate
741 the hash tables, type translation table, and pointer table. */
743 if ((fp
->ctf_structs
.ctn_readonly
744 = ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
745 ctf_hash_eq_string
)) == NULL
)
748 if ((fp
->ctf_unions
.ctn_readonly
749 = ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
750 ctf_hash_eq_string
)) == NULL
)
753 if ((fp
->ctf_enums
.ctn_readonly
754 = ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
755 ctf_hash_eq_string
)) == NULL
)
758 if ((fp
->ctf_names
.ctn_readonly
759 = ctf_hash_create (pop
[CTF_K_INTEGER
] +
761 pop
[CTF_K_FUNCTION
] +
764 pop
[CTF_K_VOLATILE
] +
768 ctf_hash_eq_string
)) == NULL
)
771 fp
->ctf_txlate
= malloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
772 fp
->ctf_ptrtab_len
= fp
->ctf_typemax
+ 1;
773 fp
->ctf_ptrtab
= malloc (sizeof (uint32_t) * fp
->ctf_ptrtab_len
);
775 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
776 return ENOMEM
; /* Memory allocation failed. */
779 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
781 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
782 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
784 /* In the second pass through the types, we fill in each entry of the
785 type and pointer tables and add names to the appropriate hashes. */
787 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
789 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
790 unsigned short isroot
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
791 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
792 ssize_t size
, increment
, vbytes
;
796 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
797 name
= ctf_strptr (fp
, tp
->ctt_name
);
798 /* Cannot fail: shielded by call in loop above. */
799 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
805 /* Names are reused by bit-fields, which are differentiated by their
806 encodings, and so typically we'd record only the first instance of
807 a given intrinsic. However, we replace an existing type with a
808 root-visible version so that we can be sure to find it when
809 checking for conflicting definitions in ctf_add_type(). */
811 if (((ctf_hash_lookup_type (fp
->ctf_names
.ctn_readonly
,
815 err
= ctf_hash_define_type (fp
->ctf_names
.ctn_readonly
, fp
,
816 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
823 /* These kinds have no name, so do not need interning into any
833 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
834 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
841 if (size
>= CTF_LSTRUCT_THRESH
)
847 err
= ctf_hash_define_type (fp
->ctf_structs
.ctn_readonly
, fp
,
848 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
857 if (size
>= CTF_LSTRUCT_THRESH
)
863 err
= ctf_hash_define_type (fp
->ctf_unions
.ctn_readonly
, fp
,
864 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
875 err
= ctf_hash_define_type (fp
->ctf_enums
.ctn_readonly
, fp
,
876 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
887 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
888 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
896 ctf_names_t
*np
= ctf_name_table (fp
, tp
->ctt_type
);
901 /* Only insert forward tags into the given hash if the type or tag
902 name is not already present. */
903 if (ctf_hash_lookup_type (np
->ctn_readonly
, fp
, name
) == 0)
905 err
= ctf_hash_insert_type (np
->ctn_readonly
, fp
,
906 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
915 /* If the type referenced by the pointer is in this CTF dict, then
916 store the index of the pointer type in fp->ctf_ptrtab[ index of
917 referenced type ]. */
919 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
920 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
921 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
930 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
931 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
937 ctf_err_warn (fp
, 0, ECTF_CORRUPT
,
938 _("init_types(): unhandled CTF kind: %x"), kind
);
942 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
943 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
946 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
947 ctf_dprintf ("%u enum names hashed\n",
948 ctf_hash_size (fp
->ctf_enums
.ctn_readonly
));
949 ctf_dprintf ("%u struct names hashed (%d long)\n",
950 ctf_hash_size (fp
->ctf_structs
.ctn_readonly
), nlstructs
);
951 ctf_dprintf ("%u union names hashed (%d long)\n",
952 ctf_hash_size (fp
->ctf_unions
.ctn_readonly
), nlunions
);
953 ctf_dprintf ("%u base type names hashed\n",
954 ctf_hash_size (fp
->ctf_names
.ctn_readonly
));
956 /* Make an additional pass through the pointer table to find pointers that
957 point to anonymous typedef nodes. If we find one, modify the pointer table
958 so that the pointer is also known to point to the node that is referenced
959 by the anonymous typedef node. */
961 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
963 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
965 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
967 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
968 && strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0
969 && LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
970 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
971 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
978 /* Endianness-flipping routines.
980 We flip everything, mindlessly, even 1-byte entities, so that future
981 expansions do not require changes to this code. */
983 /* Flip the endianness of the CTF header. */
986 flip_header (ctf_header_t
*cth
)
988 swap_thing (cth
->cth_preamble
.ctp_magic
);
989 swap_thing (cth
->cth_preamble
.ctp_version
);
990 swap_thing (cth
->cth_preamble
.ctp_flags
);
991 swap_thing (cth
->cth_parlabel
);
992 swap_thing (cth
->cth_parname
);
993 swap_thing (cth
->cth_cuname
);
994 swap_thing (cth
->cth_objtoff
);
995 swap_thing (cth
->cth_funcoff
);
996 swap_thing (cth
->cth_objtidxoff
);
997 swap_thing (cth
->cth_funcidxoff
);
998 swap_thing (cth
->cth_varoff
);
999 swap_thing (cth
->cth_typeoff
);
1000 swap_thing (cth
->cth_stroff
);
1001 swap_thing (cth
->cth_strlen
);
1004 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
1007 flip_lbls (void *start
, size_t len
)
1009 ctf_lblent_t
*lbl
= start
;
1012 for (i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
1014 swap_thing (lbl
->ctl_label
);
1015 swap_thing (lbl
->ctl_type
);
1019 /* Flip the endianness of the data-object or function sections or their indexes,
1020 all arrays of uint32_t. */
1023 flip_objts (void *start
, size_t len
)
1025 uint32_t *obj
= start
;
1028 for (i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
1032 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
1035 flip_vars (void *start
, size_t len
)
1037 ctf_varent_t
*var
= start
;
1040 for (i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
1042 swap_thing (var
->ctv_name
);
1043 swap_thing (var
->ctv_type
);
1047 /* Flip the endianness of the type section, a tagged array of ctf_type or
1048 ctf_stype followed by variable data. */
1051 flip_types (ctf_dict_t
*fp
, void *start
, size_t len
)
1053 ctf_type_t
*t
= start
;
1055 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
1057 swap_thing (t
->ctt_name
);
1058 swap_thing (t
->ctt_info
);
1059 swap_thing (t
->ctt_size
);
1061 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1062 size_t size
= t
->ctt_size
;
1063 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1064 size_t vbytes
= get_vbytes_v2 (fp
, kind
, size
, vlen
);
1066 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1068 swap_thing (t
->ctt_lsizehi
);
1069 swap_thing (t
->ctt_lsizelo
);
1070 size
= CTF_TYPE_LSIZE (t
);
1071 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1074 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1082 case CTF_K_VOLATILE
:
1084 case CTF_K_RESTRICT
:
1085 /* These types have no vlen data to swap. */
1086 assert (vbytes
== 0);
1092 /* These types have a single uint32_t. */
1094 uint32_t *item
= (uint32_t *) t
;
1100 case CTF_K_FUNCTION
:
1102 /* This type has a bunch of uint32_ts. */
1104 uint32_t *item
= (uint32_t *) t
;
1107 for (i
= vlen
; i
> 0; item
++, i
--)
1114 /* This has a single ctf_array_t. */
1116 ctf_array_t
*a
= (ctf_array_t
*) t
;
1118 assert (vbytes
== sizeof (ctf_array_t
));
1119 swap_thing (a
->cta_contents
);
1120 swap_thing (a
->cta_index
);
1121 swap_thing (a
->cta_nelems
);
1128 /* This has a single ctf_slice_t. */
1130 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1132 assert (vbytes
== sizeof (ctf_slice_t
));
1133 swap_thing (s
->cts_type
);
1134 swap_thing (s
->cts_offset
);
1135 swap_thing (s
->cts_bits
);
1143 /* This has an array of ctf_member or ctf_lmember, depending on
1144 size. We could consider it to be a simple array of uint32_t,
1145 but for safety's sake in case these structures ever acquire
1146 non-uint32_t members, do it member by member. */
1148 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1150 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1152 for (i
= vlen
; i
> 0; i
--, lm
++)
1154 swap_thing (lm
->ctlm_name
);
1155 swap_thing (lm
->ctlm_offsethi
);
1156 swap_thing (lm
->ctlm_type
);
1157 swap_thing (lm
->ctlm_offsetlo
);
1162 ctf_member_t
*m
= (ctf_member_t
*) t
;
1164 for (i
= vlen
; i
> 0; i
--, m
++)
1166 swap_thing (m
->ctm_name
);
1167 swap_thing (m
->ctm_offset
);
1168 swap_thing (m
->ctm_type
);
1176 /* This has an array of ctf_enum_t. */
1178 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1181 for (i
= vlen
; i
> 0; item
++, i
--)
1183 swap_thing (item
->cte_name
);
1184 swap_thing (item
->cte_value
);
1189 ctf_err_warn (fp
, 0, ECTF_CORRUPT
,
1190 _("unhandled CTF kind in endianness conversion: %x"),
1192 return ECTF_CORRUPT
;
1195 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1201 /* Flip the endianness of BUF, given the offsets in the (already endian-
1204 All of this stuff happens before the header is fully initialized, so the
1205 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1206 data, this is no real loss. */
1209 flip_ctf (ctf_dict_t
*fp
, ctf_header_t
*cth
, unsigned char *buf
)
1211 flip_lbls (buf
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1212 flip_objts (buf
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1213 flip_objts (buf
+ cth
->cth_funcoff
, cth
->cth_objtidxoff
- cth
->cth_funcoff
);
1214 flip_objts (buf
+ cth
->cth_objtidxoff
, cth
->cth_funcidxoff
- cth
->cth_objtidxoff
);
1215 flip_objts (buf
+ cth
->cth_funcidxoff
, cth
->cth_varoff
- cth
->cth_funcidxoff
);
1216 flip_vars (buf
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1217 return flip_types (fp
, buf
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1220 /* Set up the ctl hashes in a ctf_dict_t. Called by both writable and
1221 non-writable dictionary initialization. */
1222 void ctf_set_ctl_hashes (ctf_dict_t
*fp
)
1224 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1225 array of type name prefixes and the corresponding ctf_hash to use. */
1226 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1227 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1228 fp
->ctf_lookups
[0].ctl_hash
= &fp
->ctf_structs
;
1229 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1230 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1231 fp
->ctf_lookups
[1].ctl_hash
= &fp
->ctf_unions
;
1232 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1233 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1234 fp
->ctf_lookups
[2].ctl_hash
= &fp
->ctf_enums
;
1235 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1236 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1237 fp
->ctf_lookups
[3].ctl_hash
= &fp
->ctf_names
;
1238 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1239 fp
->ctf_lookups
[4].ctl_len
= 0;
1240 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1243 /* Open a CTF file, mocking up a suitable ctf_sect. */
1245 ctf_dict_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1246 const char *symsect
, size_t symsect_size
,
1247 size_t symsect_entsize
,
1248 const char *strsect
, size_t strsect_size
,
1251 return ctf_simple_open_internal (ctfsect
, ctfsect_size
, symsect
, symsect_size
,
1252 symsect_entsize
, strsect
, strsect_size
, NULL
,
1256 /* Open a CTF file, mocking up a suitable ctf_sect and overriding the external
1257 strtab with a synthetic one. */
1259 ctf_dict_t
*ctf_simple_open_internal (const char *ctfsect
, size_t ctfsect_size
,
1260 const char *symsect
, size_t symsect_size
,
1261 size_t symsect_entsize
,
1262 const char *strsect
, size_t strsect_size
,
1263 ctf_dynhash_t
*syn_strtab
, int writable
,
1266 ctf_sect_t skeleton
;
1268 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1269 ctf_sect_t
*ctfsectp
= NULL
;
1270 ctf_sect_t
*symsectp
= NULL
;
1271 ctf_sect_t
*strsectp
= NULL
;
1273 skeleton
.cts_name
= _CTF_SECTION
;
1274 skeleton
.cts_entsize
= 1;
1278 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1279 ctf_sect
.cts_data
= ctfsect
;
1280 ctf_sect
.cts_size
= ctfsect_size
;
1281 ctfsectp
= &ctf_sect
;
1286 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1287 sym_sect
.cts_data
= symsect
;
1288 sym_sect
.cts_size
= symsect_size
;
1289 sym_sect
.cts_entsize
= symsect_entsize
;
1290 symsectp
= &sym_sect
;
1295 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1296 str_sect
.cts_data
= strsect
;
1297 str_sect
.cts_size
= strsect_size
;
1298 strsectp
= &str_sect
;
1301 return ctf_bufopen_internal (ctfsectp
, symsectp
, strsectp
, syn_strtab
,
1305 /* Decode the specified CTF buffer and optional symbol table, and create a new
1306 CTF dict representing the symbolic debugging information. This code can
1307 be used directly by the debugger, or it can be used as the engine for
1308 ctf_fdopen() or ctf_open(), below. */
1311 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1312 const ctf_sect_t
*strsect
, int *errp
)
1314 return ctf_bufopen_internal (ctfsect
, symsect
, strsect
, NULL
, 0, errp
);
1317 /* Like ctf_bufopen, but overriding the external strtab with a synthetic one. */
1320 ctf_bufopen_internal (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1321 const ctf_sect_t
*strsect
, ctf_dynhash_t
*syn_strtab
,
1322 int writable
, int *errp
)
1324 const ctf_preamble_t
*pp
;
1325 size_t hdrsz
= sizeof (ctf_header_t
);
1328 int foreign_endian
= 0;
1331 libctf_init_debug();
1333 if ((ctfsect
== NULL
) || ((symsect
!= NULL
) &&
1334 ((strsect
== NULL
) && syn_strtab
== NULL
)))
1335 return (ctf_set_open_errno (errp
, EINVAL
));
1337 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1338 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1339 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1341 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1342 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1344 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1345 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1347 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1348 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1350 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1352 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1353 pp
->ctp_magic
, pp
->ctp_version
);
1355 /* Validate each part of the CTF header.
1357 First, we validate the preamble (common to all versions). At that point,
1358 we know the endianness and specific header version, and can validate the
1359 version-specific parts including section offsets and alignments.
1361 We specifically do not support foreign-endian old versions. */
1363 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1365 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1367 if (pp
->ctp_version
!= CTF_VERSION_3
)
1368 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1372 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1375 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1376 || (pp
->ctp_version
> CTF_VERSION_3
)))
1377 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1379 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1381 /* The symtab can contain function entries which contain embedded ctf
1382 info. We do not support dynamically upgrading such entries (none
1383 should exist in any case, since dwarf2ctf does not create them). */
1385 ctf_err_warn (NULL
, 0, ECTF_NOTSUP
, _("ctf_bufopen: CTF version %d "
1386 "symsect not supported"),
1388 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1391 if (pp
->ctp_version
< CTF_VERSION_3
)
1392 hdrsz
= sizeof (ctf_header_v2_t
);
1394 if (_libctf_unlikely_ (pp
->ctp_flags
> CTF_F_MAX
))
1396 ctf_err_warn (NULL
, 0, ECTF_FLAGS
, _("ctf_bufopen: invalid header "
1398 (unsigned int) pp
->ctp_flags
);
1399 return (ctf_set_open_errno (errp
, ECTF_FLAGS
));
1402 if (ctfsect
->cts_size
< hdrsz
)
1403 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1405 if ((fp
= malloc (sizeof (ctf_dict_t
))) == NULL
)
1406 return (ctf_set_open_errno (errp
, ENOMEM
));
1408 memset (fp
, 0, sizeof (ctf_dict_t
));
1411 fp
->ctf_flags
|= LCTF_RDWR
;
1413 if ((fp
->ctf_header
= malloc (sizeof (struct ctf_header
))) == NULL
)
1416 return (ctf_set_open_errno (errp
, ENOMEM
));
1418 hp
= fp
->ctf_header
;
1419 memcpy (hp
, ctfsect
->cts_data
, hdrsz
);
1420 if (pp
->ctp_version
< CTF_VERSION_3
)
1421 upgrade_header (hp
);
1425 fp
->ctf_openflags
= hp
->cth_flags
;
1426 fp
->ctf_size
= hp
->cth_stroff
+ hp
->cth_strlen
;
1428 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1429 (unsigned long) fp
->ctf_size
);
1431 if (hp
->cth_lbloff
> fp
->ctf_size
|| hp
->cth_objtoff
> fp
->ctf_size
1432 || hp
->cth_funcoff
> fp
->ctf_size
|| hp
->cth_objtidxoff
> fp
->ctf_size
1433 || hp
->cth_funcidxoff
> fp
->ctf_size
|| hp
->cth_typeoff
> fp
->ctf_size
1434 || hp
->cth_stroff
> fp
->ctf_size
)
1436 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
, _("header offset exceeds CTF size"));
1437 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1440 if (hp
->cth_lbloff
> hp
->cth_objtoff
1441 || hp
->cth_objtoff
> hp
->cth_funcoff
1442 || hp
->cth_funcoff
> hp
->cth_typeoff
1443 || hp
->cth_funcoff
> hp
->cth_objtidxoff
1444 || hp
->cth_objtidxoff
> hp
->cth_funcidxoff
1445 || hp
->cth_funcidxoff
> hp
->cth_varoff
1446 || hp
->cth_varoff
> hp
->cth_typeoff
|| hp
->cth_typeoff
> hp
->cth_stroff
)
1448 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
, _("overlapping CTF sections"));
1449 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1452 if ((hp
->cth_lbloff
& 3) || (hp
->cth_objtoff
& 2)
1453 || (hp
->cth_funcoff
& 2) || (hp
->cth_objtidxoff
& 2)
1454 || (hp
->cth_funcidxoff
& 2) || (hp
->cth_varoff
& 3)
1455 || (hp
->cth_typeoff
& 3))
1457 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
,
1458 _("CTF sections not properly aligned"));
1459 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1462 /* This invariant will be lifted in v4, but for now it is true. */
1464 if ((hp
->cth_funcidxoff
- hp
->cth_objtidxoff
!= 0) &&
1465 (hp
->cth_funcidxoff
- hp
->cth_objtidxoff
1466 != hp
->cth_funcoff
- hp
->cth_objtoff
))
1468 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
,
1469 _("Object index section exists is neither empty nor the "
1470 "same length as the object section: %u versus %u "
1471 "bytes"), hp
->cth_funcoff
- hp
->cth_objtoff
,
1472 hp
->cth_funcidxoff
- hp
->cth_objtidxoff
);
1473 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1476 if ((hp
->cth_varoff
- hp
->cth_funcidxoff
!= 0) &&
1477 (hp
->cth_varoff
- hp
->cth_funcidxoff
1478 != hp
->cth_objtidxoff
- hp
->cth_funcoff
))
1480 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
,
1481 _("Function index section exists is neither empty nor the "
1482 "same length as the function section: %u versus %u "
1483 "bytes"), hp
->cth_objtidxoff
- hp
->cth_funcoff
,
1484 hp
->cth_varoff
- hp
->cth_funcidxoff
);
1485 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1488 /* Once everything is determined to be valid, attempt to decompress the CTF
1489 data buffer if it is compressed, or copy it into new storage if it is not
1490 compressed but needs endian-flipping. Otherwise we just put the data
1491 section's buffer pointer into ctf_buf, below. */
1493 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1496 if (hp
->cth_flags
& CTF_F_COMPRESS
)
1503 /* We are allocating this ourselves, so we can drop the ctf header
1504 copy in favour of ctf->ctf_header. */
1506 if ((fp
->ctf_base
= malloc (fp
->ctf_size
)) == NULL
)
1511 fp
->ctf_dynbase
= fp
->ctf_base
;
1512 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
1514 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1515 srclen
= ctfsect
->cts_size
- hdrsz
;
1516 dstlen
= fp
->ctf_size
;
1517 fp
->ctf_buf
= fp
->ctf_base
;
1519 if ((rc
= uncompress (fp
->ctf_base
, &dstlen
, src
, srclen
)) != Z_OK
)
1521 ctf_err_warn (NULL
, 0, ECTF_DECOMPRESS
, _("zlib inflate err: %s"),
1523 err
= ECTF_DECOMPRESS
;
1527 if ((size_t) dstlen
!= fp
->ctf_size
)
1529 ctf_err_warn (NULL
, 0, ECTF_CORRUPT
,
1530 _("zlib inflate short: got %lu of %lu bytes"),
1531 (unsigned long) dstlen
, (unsigned long) fp
->ctf_size
);
1536 else if (foreign_endian
)
1538 if ((fp
->ctf_base
= malloc (fp
->ctf_size
)) == NULL
)
1543 fp
->ctf_dynbase
= fp
->ctf_base
;
1544 memcpy (fp
->ctf_base
, ((unsigned char *) ctfsect
->cts_data
) + hdrsz
,
1546 fp
->ctf_buf
= fp
->ctf_base
;
1550 /* We are just using the section passed in -- but its header may be an old
1551 version. Point ctf_buf past the old header, and never touch it
1553 fp
->ctf_base
= (unsigned char *) ctfsect
->cts_data
;
1554 fp
->ctf_dynbase
= NULL
;
1555 fp
->ctf_buf
= fp
->ctf_base
+ hdrsz
;
1558 /* Once we have uncompressed and validated the CTF data buffer, we can
1559 proceed with initializing the ctf_dict_t we allocated above.
1561 Nothing that depends on buf or base should be set directly in this function
1562 before the init_types() call, because it may be reallocated during
1563 transparent upgrade if this recension of libctf is so configured: see
1566 ctf_set_version (fp
, hp
, hp
->cth_version
);
1567 ctf_str_create_atoms (fp
);
1568 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1569 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1571 if (symsect
!= NULL
)
1573 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1574 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1577 if (fp
->ctf_data
.cts_name
!= NULL
)
1578 if ((fp
->ctf_data
.cts_name
= strdup (fp
->ctf_data
.cts_name
)) == NULL
)
1583 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1584 if ((fp
->ctf_symtab
.cts_name
= strdup (fp
->ctf_symtab
.cts_name
)) == NULL
)
1589 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1590 if ((fp
->ctf_strtab
.cts_name
= strdup (fp
->ctf_strtab
.cts_name
)) == NULL
)
1596 if (fp
->ctf_data
.cts_name
== NULL
)
1597 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1598 if (fp
->ctf_symtab
.cts_name
== NULL
)
1599 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1600 if (fp
->ctf_strtab
.cts_name
== NULL
)
1601 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1603 if (strsect
!= NULL
)
1605 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1606 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1608 fp
->ctf_syn_ext_strtab
= syn_strtab
;
1610 if (foreign_endian
&&
1611 (err
= flip_ctf (fp
, hp
, fp
->ctf_buf
)) != 0)
1613 /* We can be certain that flip_ctf() will have endian-flipped everything
1614 other than the types table when we return. In particular the header
1615 is fine, so set it, to allow freeing to use the usual code path. */
1617 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1621 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1623 /* No need to do anything else for dynamic dicts: they do not support symbol
1624 lookups, and the type table is maintained in the dthashes. */
1625 if (fp
->ctf_flags
& LCTF_RDWR
)
1631 if ((err
= init_types (fp
, hp
)) != 0)
1634 /* Allocate and initialize the symtab translation table, pointed to by
1635 ctf_sxlate, and the corresponding index sections. This table may be too
1636 large for the actual size of the object and function info sections: if so,
1637 ctf_nsyms will be adjusted and the excess will never be used. It's
1638 possible to do indexed symbol lookups even without a symbol table, so check
1639 even in that case. Initially, we assume the symtab is native-endian: if it
1640 isn't, the caller will inform us later by calling ctf_symsect_endianness. */
1641 #ifdef WORDS_BIGENDIAN
1642 fp
->ctf_symsect_little_endian
= 0;
1644 fp
->ctf_symsect_little_endian
= 1;
1647 if (symsect
!= NULL
)
1649 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1650 fp
->ctf_sxlate
= malloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1652 if (fp
->ctf_sxlate
== NULL
)
1659 if ((err
= init_symtab (fp
, hp
, symsect
)) != 0)
1662 ctf_set_ctl_hashes (fp
);
1664 if (symsect
!= NULL
)
1666 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1667 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1669 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1672 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1678 ctf_set_open_errno (errp
, err
);
1679 ctf_err_warn_to_open (fp
);
1680 ctf_dict_close (fp
);
1684 /* Bump the refcount on the specified CTF dict, to allow export of ctf_dict_t's
1685 from iterators that open and close the ctf_dict_t around the loop. (This
1686 does not extend their lifetime beyond that of the ctf_archive_t in which they
1690 ctf_ref (ctf_dict_t
*fp
)
1695 /* Close the specified CTF dict and free associated data structures. Note that
1696 ctf_dict_close() is a reference counted operation: if the specified file is
1697 the parent of other active dict, its reference count will be greater than one
1698 and it will be freed later when no active children exist. */
1701 ctf_dict_close (ctf_dict_t
*fp
)
1703 ctf_dtdef_t
*dtd
, *ntd
;
1704 ctf_dvdef_t
*dvd
, *nvd
;
1705 ctf_in_flight_dynsym_t
*did
, *nid
;
1706 ctf_err_warning_t
*err
, *nerr
;
1709 return; /* Allow ctf_dict_close(NULL) to simplify caller code. */
1711 ctf_dprintf ("ctf_dict_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1713 if (fp
->ctf_refcnt
> 1)
1719 /* It is possible to recurse back in here, notably if dicts in the
1720 ctf_link_inputs or ctf_link_outputs cite this dict as a parent without
1721 using ctf_import_unref. Do nothing in that case. */
1722 if (fp
->ctf_refcnt
== 0)
1726 free (fp
->ctf_dyncuname
);
1727 free (fp
->ctf_dynparname
);
1728 if (fp
->ctf_parent
&& !fp
->ctf_parent_unreffed
)
1729 ctf_dict_close (fp
->ctf_parent
);
1731 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1733 ntd
= ctf_list_next (dtd
);
1734 ctf_dtd_delete (fp
, dtd
);
1736 ctf_dynhash_destroy (fp
->ctf_dthash
);
1737 if (fp
->ctf_flags
& LCTF_RDWR
)
1739 ctf_dynhash_destroy (fp
->ctf_structs
.ctn_writable
);
1740 ctf_dynhash_destroy (fp
->ctf_unions
.ctn_writable
);
1741 ctf_dynhash_destroy (fp
->ctf_enums
.ctn_writable
);
1742 ctf_dynhash_destroy (fp
->ctf_names
.ctn_writable
);
1746 ctf_hash_destroy (fp
->ctf_structs
.ctn_readonly
);
1747 ctf_hash_destroy (fp
->ctf_unions
.ctn_readonly
);
1748 ctf_hash_destroy (fp
->ctf_enums
.ctn_readonly
);
1749 ctf_hash_destroy (fp
->ctf_names
.ctn_readonly
);
1752 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1754 nvd
= ctf_list_next (dvd
);
1755 ctf_dvd_delete (fp
, dvd
);
1757 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1759 free (fp
->ctf_funcidx_sxlate
);
1760 free (fp
->ctf_objtidx_sxlate
);
1761 ctf_dynhash_destroy (fp
->ctf_objthash
);
1762 ctf_dynhash_destroy (fp
->ctf_funchash
);
1763 free (fp
->ctf_dynsymidx
);
1764 ctf_dynhash_destroy (fp
->ctf_dynsyms
);
1765 for (did
= ctf_list_next (&fp
->ctf_in_flight_dynsyms
); did
!= NULL
; did
= nid
)
1767 nid
= ctf_list_next (did
);
1768 ctf_list_delete (&fp
->ctf_in_flight_dynsyms
, did
);
1772 ctf_str_free_atoms (fp
);
1773 free (fp
->ctf_tmp_typeslice
);
1775 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
)
1776 free ((char *) fp
->ctf_data
.cts_name
);
1778 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
)
1779 free ((char *) fp
->ctf_symtab
.cts_name
);
1781 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
)
1782 free ((char *) fp
->ctf_strtab
.cts_name
);
1783 else if (fp
->ctf_data_mmapped
)
1784 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1786 free (fp
->ctf_dynbase
);
1788 ctf_dynhash_destroy (fp
->ctf_syn_ext_strtab
);
1789 ctf_dynhash_destroy (fp
->ctf_link_inputs
);
1790 ctf_dynhash_destroy (fp
->ctf_link_outputs
);
1791 ctf_dynhash_destroy (fp
->ctf_link_type_mapping
);
1792 ctf_dynhash_destroy (fp
->ctf_link_in_cu_mapping
);
1793 ctf_dynhash_destroy (fp
->ctf_link_out_cu_mapping
);
1794 ctf_dynhash_destroy (fp
->ctf_add_processing
);
1795 ctf_dedup_fini (fp
, NULL
, 0);
1796 ctf_dynset_destroy (fp
->ctf_dedup_atoms_alloc
);
1798 for (err
= ctf_list_next (&fp
->ctf_errs_warnings
); err
!= NULL
; err
= nerr
)
1800 nerr
= ctf_list_next (err
);
1801 ctf_list_delete (&fp
->ctf_errs_warnings
, err
);
1802 free (err
->cew_text
);
1806 free (fp
->ctf_sxlate
);
1807 free (fp
->ctf_txlate
);
1808 free (fp
->ctf_ptrtab
);
1809 free (fp
->ctf_pptrtab
);
1811 free (fp
->ctf_header
);
1815 /* Backward compatibility. */
1817 ctf_file_close (ctf_file_t
*fp
)
1819 ctf_dict_close (fp
);
1822 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1823 archive, so closing one is just like closing an archive. */
1825 ctf_close (ctf_archive_t
*arc
)
1827 ctf_arc_close (arc
);
1830 /* Get the CTF archive from which this ctf_dict_t is derived. */
1832 ctf_get_arc (const ctf_dict_t
*fp
)
1834 return fp
->ctf_archive
;
1837 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1838 ctfsect's data * after ctf_dict_close(), which is why we return the actual
1839 structure, not a pointer to it, since that is likely to become a pointer to
1840 freed data before the return value is used under the expected use case of
1841 ctf_getsect()/ ctf_dict_close()/free(). */
1843 ctf_getdatasect (const ctf_dict_t
*fp
)
1845 return fp
->ctf_data
;
1849 ctf_getsymsect (const ctf_dict_t
*fp
)
1851 return fp
->ctf_symtab
;
1855 ctf_getstrsect (const ctf_dict_t
*fp
)
1857 return fp
->ctf_strtab
;
1860 /* Set the endianness of the symbol table attached to FP. */
1862 ctf_symsect_endianness (ctf_dict_t
*fp
, int little_endian
)
1864 int old_endianness
= fp
->ctf_symsect_little_endian
;
1866 fp
->ctf_symsect_little_endian
= !!little_endian
;
1868 /* If we already have a symtab translation table, we need to repopulate it if
1869 our idea of the endianness has changed. */
1871 if (old_endianness
!= fp
->ctf_symsect_little_endian
1872 && fp
->ctf_sxlate
!= NULL
&& fp
->ctf_symtab
.cts_data
!= NULL
)
1873 assert (init_symtab (fp
, fp
->ctf_header
, &fp
->ctf_symtab
) == 0);
1876 /* Return the CTF handle for the parent CTF dict, if one exists. Otherwise
1877 return NULL to indicate this dict has no imported parent. */
1879 ctf_parent_dict (ctf_dict_t
*fp
)
1881 return fp
->ctf_parent
;
1884 /* Backward compatibility. */
1886 ctf_parent_file (ctf_dict_t
*fp
)
1888 return ctf_parent_dict (fp
);
1891 /* Return the name of the parent CTF dict, if one exists, or NULL otherwise. */
1893 ctf_parent_name (ctf_dict_t
*fp
)
1895 return fp
->ctf_parname
;
1898 /* Set the parent name. It is an error to call this routine without calling
1899 ctf_import() at some point. */
1901 ctf_parent_name_set (ctf_dict_t
*fp
, const char *name
)
1903 if (fp
->ctf_dynparname
!= NULL
)
1904 free (fp
->ctf_dynparname
);
1906 if ((fp
->ctf_dynparname
= strdup (name
)) == NULL
)
1907 return (ctf_set_errno (fp
, ENOMEM
));
1908 fp
->ctf_parname
= fp
->ctf_dynparname
;
1912 /* Return the name of the compilation unit this CTF file applies to. Usually
1913 non-NULL only for non-parent dicts. */
1915 ctf_cuname (ctf_dict_t
*fp
)
1917 return fp
->ctf_cuname
;
1920 /* Set the compilation unit name. */
1922 ctf_cuname_set (ctf_dict_t
*fp
, const char *name
)
1924 if (fp
->ctf_dyncuname
!= NULL
)
1925 free (fp
->ctf_dyncuname
);
1927 if ((fp
->ctf_dyncuname
= strdup (name
)) == NULL
)
1928 return (ctf_set_errno (fp
, ENOMEM
));
1929 fp
->ctf_cuname
= fp
->ctf_dyncuname
;
1933 /* Import the types from the specified parent dict by storing a pointer to it in
1934 ctf_parent and incrementing its reference count. Only one parent is allowed:
1935 if a parent already exists, it is replaced by the new parent. The pptrtab
1936 is wiped, and will be refreshed by the next ctf_lookup_by_name call. */
1938 ctf_import (ctf_dict_t
*fp
, ctf_dict_t
*pfp
)
1940 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1941 return (ctf_set_errno (fp
, EINVAL
));
1943 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1944 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1946 if (fp
->ctf_parent
&& !fp
->ctf_parent_unreffed
)
1947 ctf_dict_close (fp
->ctf_parent
);
1948 fp
->ctf_parent
= NULL
;
1950 free (fp
->ctf_pptrtab
);
1951 fp
->ctf_pptrtab
= NULL
;
1952 fp
->ctf_pptrtab_len
= 0;
1953 fp
->ctf_pptrtab_typemax
= 0;
1959 if (fp
->ctf_parname
== NULL
)
1960 if ((err
= ctf_parent_name_set (fp
, "PARENT")) < 0)
1963 fp
->ctf_flags
|= LCTF_CHILD
;
1965 fp
->ctf_parent_unreffed
= 0;
1968 fp
->ctf_parent
= pfp
;
1972 /* Like ctf_import, but does not increment the refcount on the imported parent
1973 or close it at any point: as a result it can go away at any time and the
1974 caller must do all freeing itself. Used internally to avoid refcount
1977 ctf_import_unref (ctf_dict_t
*fp
, ctf_dict_t
*pfp
)
1979 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1980 return (ctf_set_errno (fp
, EINVAL
));
1982 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1983 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1985 if (fp
->ctf_parent
&& !fp
->ctf_parent_unreffed
)
1986 ctf_dict_close (fp
->ctf_parent
);
1987 fp
->ctf_parent
= NULL
;
1989 free (fp
->ctf_pptrtab
);
1990 fp
->ctf_pptrtab
= NULL
;
1991 fp
->ctf_pptrtab_len
= 0;
1992 fp
->ctf_pptrtab_typemax
= 0;
1997 if (fp
->ctf_parname
== NULL
)
1998 if ((err
= ctf_parent_name_set (fp
, "PARENT")) < 0)
2001 fp
->ctf_flags
|= LCTF_CHILD
;
2002 fp
->ctf_parent_unreffed
= 1;
2005 fp
->ctf_parent
= pfp
;
2009 /* Set the data model constant for the CTF dict. */
2011 ctf_setmodel (ctf_dict_t
*fp
, int model
)
2013 const ctf_dmodel_t
*dp
;
2015 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
2017 if (dp
->ctd_code
== model
)
2019 fp
->ctf_dmodel
= dp
;
2024 return (ctf_set_errno (fp
, EINVAL
));
2027 /* Return the data model constant for the CTF dict. */
2029 ctf_getmodel (ctf_dict_t
*fp
)
2031 return fp
->ctf_dmodel
->ctd_code
;
2034 /* The caller can hang an arbitrary pointer off each ctf_dict_t using this
2037 ctf_setspecific (ctf_dict_t
*fp
, void *data
)
2039 fp
->ctf_specific
= data
;
2042 /* Retrieve the arbitrary pointer again. */
2044 ctf_getspecific (ctf_dict_t
*fp
)
2046 return fp
->ctf_specific
;