2 Copyright (C) 2019-2020 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>
32 static const ctf_dmodel_t _libctf_models
[] = {
33 {"ILP32", CTF_MODEL_ILP32
, 4, 1, 2, 4, 4},
34 {"LP64", CTF_MODEL_LP64
, 8, 1, 2, 4, 8},
35 {NULL
, 0, 0, 0, 0, 0, 0}
38 const char _CTF_SECTION
[] = ".ctf";
39 const char _CTF_NULLSTR
[] = "";
41 /* Version-sensitive accessors. */
44 get_kind_v1 (uint32_t info
)
46 return (CTF_V1_INFO_KIND (info
));
50 get_root_v1 (uint32_t info
)
52 return (CTF_V1_INFO_ISROOT (info
));
56 get_vlen_v1 (uint32_t info
)
58 return (CTF_V1_INFO_VLEN (info
));
62 get_kind_v2 (uint32_t info
)
64 return (CTF_V2_INFO_KIND (info
));
68 get_root_v2 (uint32_t info
)
70 return (CTF_V2_INFO_ISROOT (info
));
74 get_vlen_v2 (uint32_t info
)
76 return (CTF_V2_INFO_VLEN (info
));
80 get_ctt_size_common (const ctf_file_t
*fp _libctf_unused_
,
81 const ctf_type_t
*tp _libctf_unused_
,
82 ssize_t
*sizep
, ssize_t
*incrementp
, size_t lsize
,
83 size_t csize
, size_t ctf_type_size
,
84 size_t ctf_stype_size
, size_t ctf_lsize_sent
)
86 ssize_t size
, increment
;
88 if (csize
== ctf_lsize_sent
)
91 increment
= ctf_type_size
;
96 increment
= ctf_stype_size
;
102 *incrementp
= increment
;
108 get_ctt_size_v1 (const ctf_file_t
*fp
, const ctf_type_t
*tp
,
109 ssize_t
*sizep
, ssize_t
*incrementp
)
111 ctf_type_v1_t
*t1p
= (ctf_type_v1_t
*) tp
;
113 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
114 CTF_TYPE_LSIZE (t1p
), t1p
->ctt_size
,
115 sizeof (ctf_type_v1_t
), sizeof (ctf_stype_v1_t
),
119 /* Return the size that a v1 will be once it is converted to v2. */
122 get_ctt_size_v2_unconverted (const ctf_file_t
*fp
, const ctf_type_t
*tp
,
123 ssize_t
*sizep
, ssize_t
*incrementp
)
125 ctf_type_v1_t
*t1p
= (ctf_type_v1_t
*) tp
;
127 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
128 CTF_TYPE_LSIZE (t1p
), t1p
->ctt_size
,
129 sizeof (ctf_type_t
), sizeof (ctf_stype_t
),
134 get_ctt_size_v2 (const ctf_file_t
*fp
, const ctf_type_t
*tp
,
135 ssize_t
*sizep
, ssize_t
*incrementp
)
137 return (get_ctt_size_common (fp
, tp
, sizep
, incrementp
,
138 CTF_TYPE_LSIZE (tp
), tp
->ctt_size
,
139 sizeof (ctf_type_t
), sizeof (ctf_stype_t
),
144 get_vbytes_common (unsigned short kind
, ssize_t size _libctf_unused_
,
151 return (sizeof (uint32_t));
153 return (sizeof (ctf_slice_t
));
155 return (sizeof (ctf_enum_t
) * vlen
);
165 ctf_dprintf ("detected invalid CTF kind -- %x\n", kind
);
171 get_vbytes_v1 (unsigned short kind
, ssize_t size
, size_t vlen
)
176 return (sizeof (ctf_array_v1_t
));
178 return (sizeof (unsigned short) * (vlen
+ (vlen
& 1)));
181 if (size
< CTF_LSTRUCT_THRESH_V1
)
182 return (sizeof (ctf_member_v1_t
) * vlen
);
184 return (sizeof (ctf_lmember_v1_t
) * vlen
);
187 return (get_vbytes_common (kind
, size
, vlen
));
191 get_vbytes_v2 (unsigned short kind
, ssize_t size
, size_t vlen
)
196 return (sizeof (ctf_array_t
));
198 return (sizeof (uint32_t) * (vlen
+ (vlen
& 1)));
201 if (size
< CTF_LSTRUCT_THRESH
)
202 return (sizeof (ctf_member_t
) * vlen
);
204 return (sizeof (ctf_lmember_t
) * vlen
);
207 return (get_vbytes_common (kind
, size
, vlen
));
210 static const ctf_fileops_t ctf_fileops
[] = {
211 {NULL
, NULL
, NULL
, NULL
, NULL
},
213 {get_kind_v1
, get_root_v1
, get_vlen_v1
, get_ctt_size_v1
, get_vbytes_v1
},
214 /* CTF_VERSION_1_UPGRADED_3 */
215 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
217 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
218 /* CTF_VERSION_3, identical to 2: only new type kinds */
219 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
222 /* Initialize the symtab translation table by filling each entry with the
223 offset of the CTF type or function data corresponding to each STT_FUNC or
224 STT_OBJECT entry in the symbol table. */
227 init_symtab (ctf_file_t
*fp
, const ctf_header_t
*hp
,
228 const ctf_sect_t
*sp
, const ctf_sect_t
*strp
)
230 const unsigned char *symp
= sp
->cts_data
;
231 uint32_t *xp
= fp
->ctf_sxlate
;
232 uint32_t *xend
= xp
+ fp
->ctf_nsyms
;
234 uint32_t objtoff
= hp
->cth_objtoff
;
235 uint32_t funcoff
= hp
->cth_funcoff
;
241 /* The CTF data object and function type sections are ordered to match
242 the relative order of the respective symbol types in the symtab.
243 If no type information is available for a symbol table entry, a
244 pad is inserted in the CTF section. As a further optimization,
245 anonymous or undefined symbols are omitted from the CTF data. */
247 for (; xp
< xend
; xp
++, symp
+= sp
->cts_entsize
)
249 if (sp
->cts_entsize
== sizeof (Elf32_Sym
))
250 gsp
= ctf_sym_to_elf64 ((Elf32_Sym
*) (uintptr_t) symp
, &sym
);
252 gsp
= (Elf64_Sym
*) (uintptr_t) symp
;
254 if (gsp
->st_name
< strp
->cts_size
)
255 name
= (const char *) strp
->cts_data
+ gsp
->st_name
;
259 if (gsp
->st_name
== 0 || gsp
->st_shndx
== SHN_UNDEF
260 || strcmp (name
, "_START_") == 0 || strcmp (name
, "_END_") == 0)
266 switch (ELF64_ST_TYPE (gsp
->st_info
))
269 if (objtoff
>= hp
->cth_funcoff
270 || (gsp
->st_shndx
== SHN_EXTABS
&& gsp
->st_value
== 0))
277 objtoff
+= sizeof (uint32_t);
281 if (funcoff
>= hp
->cth_objtidxoff
)
289 info
= *(uint32_t *) ((uintptr_t) fp
->ctf_buf
+ funcoff
);
290 vlen
= LCTF_INFO_VLEN (fp
, info
);
292 /* If we encounter a zero pad at the end, just skip it. Otherwise
293 skip over the function and its return type (+2) and the argument
296 if (LCTF_INFO_KIND (fp
, info
) == CTF_K_UNKNOWN
&& vlen
== 0)
297 funcoff
+= sizeof (uint32_t); /* Skip pad. */
299 funcoff
+= sizeof (uint32_t) * (vlen
+ 2);
308 ctf_dprintf ("loaded %lu symtab entries\n", fp
->ctf_nsyms
);
312 /* Reset the CTF base pointer and derive the buf pointer from it, initializing
313 everything in the ctf_file that depends on the base or buf pointers.
315 The original gap between the buf and base pointers, if any -- the original,
316 unconverted CTF header -- is kept, but its contents are not specified and are
320 ctf_set_base (ctf_file_t
*fp
, const ctf_header_t
*hp
, unsigned char *base
)
322 fp
->ctf_buf
= base
+ (fp
->ctf_buf
- fp
->ctf_base
);
324 fp
->ctf_vars
= (ctf_varent_t
*) ((const char *) fp
->ctf_buf
+
326 fp
->ctf_nvars
= (hp
->cth_typeoff
- hp
->cth_varoff
) / sizeof (ctf_varent_t
);
328 fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
= (const char *) fp
->ctf_buf
330 fp
->ctf_str
[CTF_STRTAB_0
].cts_len
= hp
->cth_strlen
;
332 /* If we have a parent container name and label, store the relocated
333 string pointers in the CTF container for easy access later. */
335 /* Note: before conversion, these will be set to values that will be
336 immediately invalidated by the conversion process, but the conversion
337 process will call ctf_set_base() again to fix things up. */
339 if (hp
->cth_parlabel
!= 0)
340 fp
->ctf_parlabel
= ctf_strptr (fp
, hp
->cth_parlabel
);
341 if (hp
->cth_parname
!= 0)
342 fp
->ctf_parname
= ctf_strptr (fp
, hp
->cth_parname
);
343 if (hp
->cth_cuname
!= 0)
344 fp
->ctf_cuname
= ctf_strptr (fp
, hp
->cth_cuname
);
347 ctf_dprintf ("ctf_set_base: CU name %s\n", fp
->ctf_cuname
);
349 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
351 fp
->ctf_parlabel
? fp
->ctf_parlabel
: "<NULL>");
354 /* Set the version of the CTF file. */
356 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
357 the variable data list associated with each type has been upgraded: the
358 caller must ensure this has been done in advance. */
361 ctf_set_version (ctf_file_t
*fp
, ctf_header_t
*cth
, int ctf_version
)
363 fp
->ctf_version
= ctf_version
;
364 cth
->cth_version
= ctf_version
;
365 fp
->ctf_fileops
= &ctf_fileops
[ctf_version
];
369 /* Upgrade the header to CTF_VERSION_3. The upgrade is done in-place. */
371 upgrade_header (ctf_header_t
*hp
)
373 ctf_header_v2_t
*oldhp
= (ctf_header_v2_t
*) hp
;
375 hp
->cth_strlen
= oldhp
->cth_strlen
;
376 hp
->cth_stroff
= oldhp
->cth_stroff
;
377 hp
->cth_typeoff
= oldhp
->cth_typeoff
;
378 hp
->cth_varoff
= oldhp
->cth_varoff
;
379 hp
->cth_funcidxoff
= hp
->cth_varoff
; /* No index sections. */
380 hp
->cth_objtidxoff
= hp
->cth_funcidxoff
;
381 hp
->cth_funcoff
= oldhp
->cth_funcoff
;
382 hp
->cth_objtoff
= oldhp
->cth_objtoff
;
383 hp
->cth_lbloff
= oldhp
->cth_lbloff
;
384 hp
->cth_cuname
= 0; /* No CU name. */
387 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3)
390 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
391 not be called before reallocation is complete.
393 Sections not checked here due to nonexistence or nonpopulated state in older
394 formats: objtidx, funcidx.
396 Type kinds not checked here due to nonexistence in older formats:
399 upgrade_types_v1 (ctf_file_t
*fp
, ctf_header_t
*cth
)
401 const ctf_type_v1_t
*tbuf
;
402 const ctf_type_v1_t
*tend
;
403 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_dynbase
;
406 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
407 const ctf_type_v1_t
*tp
;
410 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
411 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
413 /* Much like init_types(), this is a two-pass process.
415 First, figure out the new type-section size needed. (It is possible,
416 in theory, for it to be less than the old size, but this is very
417 unlikely. It cannot be so small that cth_typeoff ends up of negative
418 size. We validate this with an assertion below.)
420 We must cater not only for changes in vlen and types sizes but also
421 for changes in 'increment', which happen because v2 places some types
422 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
424 for (tp
= tbuf
; tp
< tend
;
425 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
427 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
428 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
430 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
431 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
433 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
435 v2bytes
= get_vbytes_v2 (kind
, size
, vlen
);
437 if ((vbytes
< 0) || (size
< 0))
440 increase
+= v2increment
- increment
; /* May be negative. */
441 increase
+= v2bytes
- vbytes
;
444 /* Allocate enough room for the new buffer, then copy everything but the type
445 section into place, and reset the base accordingly. Leave the version
446 number unchanged, so that LCTF_INFO_* still works on the
447 as-yet-untranslated type info. */
449 if ((ctf_base
= malloc (fp
->ctf_size
+ increase
)) == NULL
)
452 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
453 never use it and it is unconverted. */
455 memcpy (ctf_base
, fp
->ctf_buf
, cth
->cth_typeoff
);
456 memcpy (ctf_base
+ cth
->cth_stroff
+ increase
,
457 fp
->ctf_buf
+ cth
->cth_stroff
, cth
->cth_strlen
);
459 memset (ctf_base
+ cth
->cth_typeoff
, 0, cth
->cth_stroff
- cth
->cth_typeoff
462 cth
->cth_stroff
+= increase
;
463 fp
->ctf_size
+= increase
;
464 assert (cth
->cth_stroff
>= cth
->cth_typeoff
);
465 fp
->ctf_base
= ctf_base
;
466 fp
->ctf_buf
= ctf_base
;
467 fp
->ctf_dynbase
= ctf_base
;
468 ctf_set_base (fp
, cth
, ctf_base
);
470 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
472 /* Iterate through all the types again, upgrading them.
474 Everything that hasn't changed can just be outright memcpy()ed.
475 Things that have changed need field-by-field consideration. */
477 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
478 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
479 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
481 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
482 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
483 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
485 void *vdata
, *v2data
;
487 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
488 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
490 t2p
->ctt_name
= tp
->ctt_name
;
491 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
502 t2p
->ctt_type
= tp
->ctt_type
;
511 if ((size_t) size
<= CTF_MAX_SIZE
)
512 t2p
->ctt_size
= size
;
515 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
516 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
521 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
522 v2bytes
= get_vbytes_v2 (kind
, v2size
, vlen
);
524 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
525 these are not identical (and having them different makes no
526 sense semantically). */
528 assert (size
== v2size
);
530 /* Now the varlen info. */
532 vdata
= (void *) ((uintptr_t) tp
+ increment
);
533 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
539 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
540 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
542 a2p
->cta_contents
= ap
->cta_contents
;
543 a2p
->cta_index
= ap
->cta_index
;
544 a2p
->cta_nelems
= ap
->cta_nelems
;
551 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
552 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
553 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
554 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
557 /* We walk all four pointers forward, but only reference the two
558 that are valid for the given size, to avoid quadruplicating all
561 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
564 if (size
< CTF_LSTRUCT_THRESH_V1
)
566 offset
= m1
->ctm_offset
;
567 tmp
.ctm_name
= m1
->ctm_name
;
568 tmp
.ctm_type
= m1
->ctm_type
;
572 offset
= CTF_LMEM_OFFSET (lm1
);
573 tmp
.ctm_name
= lm1
->ctlm_name
;
574 tmp
.ctm_type
= lm1
->ctlm_type
;
576 if (size
< CTF_LSTRUCT_THRESH
)
578 m2
->ctm_name
= tmp
.ctm_name
;
579 m2
->ctm_type
= tmp
.ctm_type
;
580 m2
->ctm_offset
= offset
;
584 lm2
->ctlm_name
= tmp
.ctm_name
;
585 lm2
->ctlm_type
= tmp
.ctm_type
;
586 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
587 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
595 unsigned short *a1
= (unsigned short *) vdata
;
596 uint32_t *a2
= (uint32_t *) v2data
;
598 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
603 /* Catch out-of-sync get_vbytes_*(). */
604 assert (vbytes
== v2bytes
);
605 memcpy (v2data
, vdata
, vbytes
);
609 /* Verify that the entire region was converted. If not, we are either
610 converting too much, or too little (leading to a buffer overrun either here
611 or at read time, in init_types().) */
613 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== cth
->cth_stroff
);
615 ctf_set_version (fp
, cth
, CTF_VERSION_1_UPGRADED_3
);
621 /* Upgrade from any earlier version. */
623 upgrade_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
625 switch (cth
->cth_version
)
627 /* v1 requires a full pass and reformatting. */
629 upgrade_types_v1 (fp
, cth
);
631 /* Already-converted v1 is just like later versions except that its
632 parent/child boundary is unchanged (and much lower). */
634 case CTF_VERSION_1_UPGRADED_3
:
635 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
637 /* v2 is just the same as v3 except for new types and sections:
638 no upgrading required. */
639 case CTF_VERSION_2
: ;
645 /* Initialize the type ID translation table with the byte offset of each type,
646 and initialize the hash tables of each named type. Upgrade the type table to
647 the latest supported representation in the process, if needed, and if this
648 recension of libctf supports upgrading. */
651 init_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
653 const ctf_type_t
*tbuf
;
654 const ctf_type_t
*tend
;
656 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
657 const ctf_type_t
*tp
;
661 /* We determine whether the container is a child or a parent based on
662 the value of cth_parname. */
664 int child
= cth
->cth_parname
!= 0;
665 int nlstructs
= 0, nlunions
= 0;
668 assert (!(fp
->ctf_flags
& LCTF_RDWR
));
670 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
673 if ((err
= upgrade_types (fp
, cth
)) != 0)
674 return err
; /* Upgrade failed. */
677 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
678 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
680 /* We make two passes through the entire type section. In this first
681 pass, we count the number of each type and the total number of types. */
683 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
685 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
686 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
687 ssize_t size
, increment
, vbytes
;
689 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
690 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
695 if (kind
== CTF_K_FORWARD
)
697 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
698 so bump that population count too. If ctt_type is unknown, treat
699 the tag as a struct. */
701 if (tp
->ctt_type
== CTF_K_UNKNOWN
|| tp
->ctt_type
>= CTF_K_MAX
)
706 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
712 ctf_dprintf ("CTF container %p is a child\n", (void *) fp
);
713 fp
->ctf_flags
|= LCTF_CHILD
;
716 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp
);
718 /* Now that we've counted up the number of each type, we can allocate
719 the hash tables, type translation table, and pointer table. */
721 if ((fp
->ctf_structs
.ctn_readonly
722 = ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
723 ctf_hash_eq_string
)) == NULL
)
726 if ((fp
->ctf_unions
.ctn_readonly
727 = ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
728 ctf_hash_eq_string
)) == NULL
)
731 if ((fp
->ctf_enums
.ctn_readonly
732 = ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
733 ctf_hash_eq_string
)) == NULL
)
736 if ((fp
->ctf_names
.ctn_readonly
737 = ctf_hash_create (pop
[CTF_K_INTEGER
] +
739 pop
[CTF_K_FUNCTION
] +
742 pop
[CTF_K_VOLATILE
] +
746 ctf_hash_eq_string
)) == NULL
)
749 fp
->ctf_txlate
= malloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
750 fp
->ctf_ptrtab_len
= fp
->ctf_typemax
+ 1;
751 fp
->ctf_ptrtab
= malloc (sizeof (uint32_t) * fp
->ctf_ptrtab_len
);
753 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
754 return ENOMEM
; /* Memory allocation failed. */
757 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
759 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
760 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
762 /* In the second pass through the types, we fill in each entry of the
763 type and pointer tables and add names to the appropriate hashes. */
765 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
767 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
768 unsigned short isroot
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
769 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
770 ssize_t size
, increment
, vbytes
;
774 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
775 name
= ctf_strptr (fp
, tp
->ctt_name
);
776 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
782 /* Names are reused by bit-fields, which are differentiated by their
783 encodings, and so typically we'd record only the first instance of
784 a given intrinsic. However, we replace an existing type with a
785 root-visible version so that we can be sure to find it when
786 checking for conflicting definitions in ctf_add_type(). */
788 if (((ctf_hash_lookup_type (fp
->ctf_names
.ctn_readonly
,
792 err
= ctf_hash_define_type (fp
->ctf_names
.ctn_readonly
, fp
,
793 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
800 /* These kinds have no name, so do not need interning into any
810 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
811 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
818 if (size
>= CTF_LSTRUCT_THRESH
)
824 err
= ctf_hash_define_type (fp
->ctf_structs
.ctn_readonly
, fp
,
825 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
834 if (size
>= CTF_LSTRUCT_THRESH
)
840 err
= ctf_hash_define_type (fp
->ctf_unions
.ctn_readonly
, fp
,
841 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
852 err
= ctf_hash_define_type (fp
->ctf_enums
.ctn_readonly
, fp
,
853 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
864 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
865 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
873 ctf_names_t
*np
= ctf_name_table (fp
, tp
->ctt_type
);
878 /* Only insert forward tags into the given hash if the type or tag
879 name is not already present. */
880 if (ctf_hash_lookup_type (np
->ctn_readonly
, fp
, name
) == 0)
882 err
= ctf_hash_insert_type (np
->ctn_readonly
, fp
,
883 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
892 /* If the type referenced by the pointer is in this CTF container,
893 then store the index of the pointer type in
894 fp->ctf_ptrtab[ index of referenced type ]. */
896 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
897 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
898 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
907 err
= ctf_hash_insert_type (fp
->ctf_names
.ctn_readonly
, fp
,
908 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
914 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
919 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
920 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
923 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
924 ctf_dprintf ("%u enum names hashed\n",
925 ctf_hash_size (fp
->ctf_enums
.ctn_readonly
));
926 ctf_dprintf ("%u struct names hashed (%d long)\n",
927 ctf_hash_size (fp
->ctf_structs
.ctn_readonly
), nlstructs
);
928 ctf_dprintf ("%u union names hashed (%d long)\n",
929 ctf_hash_size (fp
->ctf_unions
.ctn_readonly
), nlunions
);
930 ctf_dprintf ("%u base type names hashed\n",
931 ctf_hash_size (fp
->ctf_names
.ctn_readonly
));
933 /* Make an additional pass through the pointer table to find pointers that
934 point to anonymous typedef nodes. If we find one, modify the pointer table
935 so that the pointer is also known to point to the node that is referenced
936 by the anonymous typedef node. */
938 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
940 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
942 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
944 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
945 && strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0
946 && LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
947 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
948 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
955 /* Endianness-flipping routines.
957 We flip everything, mindlessly, even 1-byte entities, so that future
958 expansions do not require changes to this code. */
960 /* < C11? define away static assertions. */
962 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
963 #define _Static_assert(cond, err)
966 /* Swap the endianness of something. */
968 #define swap_thing(x) \
970 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
971 && sizeof (x) <= 8), \
972 "Invalid size, update endianness code"); \
973 switch (sizeof (x)) { \
974 case 2: x = bswap_16 (x); break; \
975 case 4: x = bswap_32 (x); break; \
976 case 8: x = bswap_64 (x); break; \
977 case 1: /* Nothing needs doing */ \
982 /* Flip the endianness of the CTF header. */
985 flip_header (ctf_header_t
*cth
)
987 swap_thing (cth
->cth_preamble
.ctp_magic
);
988 swap_thing (cth
->cth_preamble
.ctp_version
);
989 swap_thing (cth
->cth_preamble
.ctp_flags
);
990 swap_thing (cth
->cth_parlabel
);
991 swap_thing (cth
->cth_parname
);
992 swap_thing (cth
->cth_cuname
);
993 swap_thing (cth
->cth_objtoff
);
994 swap_thing (cth
->cth_funcoff
);
995 swap_thing (cth
->cth_objtidxoff
);
996 swap_thing (cth
->cth_funcidxoff
);
997 swap_thing (cth
->cth_varoff
);
998 swap_thing (cth
->cth_typeoff
);
999 swap_thing (cth
->cth_stroff
);
1000 swap_thing (cth
->cth_strlen
);
1003 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
1006 flip_lbls (void *start
, size_t len
)
1008 ctf_lblent_t
*lbl
= start
;
1011 for (i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
1013 swap_thing (lbl
->ctl_label
);
1014 swap_thing (lbl
->ctl_type
);
1018 /* Flip the endianness of the data-object or function sections or their indexes,
1019 all arrays of uint32_t. (The function section has more internal structure,
1020 but that structure is an array of uint32_t, so can be treated as one big
1021 array for byte-swapping.) */
1024 flip_objts (void *start
, size_t len
)
1026 uint32_t *obj
= start
;
1029 for (i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
1033 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
1036 flip_vars (void *start
, size_t len
)
1038 ctf_varent_t
*var
= start
;
1041 for (i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
1043 swap_thing (var
->ctv_name
);
1044 swap_thing (var
->ctv_type
);
1048 /* Flip the endianness of the type section, a tagged array of ctf_type or
1049 ctf_stype followed by variable data. */
1052 flip_types (void *start
, size_t len
)
1054 ctf_type_t
*t
= start
;
1056 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
1058 swap_thing (t
->ctt_name
);
1059 swap_thing (t
->ctt_info
);
1060 swap_thing (t
->ctt_size
);
1062 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1063 size_t size
= t
->ctt_size
;
1064 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1065 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1067 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1069 swap_thing (t
->ctt_lsizehi
);
1070 swap_thing (t
->ctt_lsizelo
);
1071 size
= CTF_TYPE_LSIZE (t
);
1072 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1075 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1083 case CTF_K_VOLATILE
:
1085 case CTF_K_RESTRICT
:
1086 /* These types have no vlen data to swap. */
1087 assert (vbytes
== 0);
1093 /* These types have a single uint32_t. */
1095 uint32_t *item
= (uint32_t *) t
;
1101 case CTF_K_FUNCTION
:
1103 /* This type has a bunch of uint32_ts. */
1105 uint32_t *item
= (uint32_t *) t
;
1108 for (i
= vlen
; i
> 0; item
++, i
--)
1115 /* This has a single ctf_array_t. */
1117 ctf_array_t
*a
= (ctf_array_t
*) t
;
1119 assert (vbytes
== sizeof (ctf_array_t
));
1120 swap_thing (a
->cta_contents
);
1121 swap_thing (a
->cta_index
);
1122 swap_thing (a
->cta_nelems
);
1129 /* This has a single ctf_slice_t. */
1131 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1133 assert (vbytes
== sizeof (ctf_slice_t
));
1134 swap_thing (s
->cts_type
);
1135 swap_thing (s
->cts_offset
);
1136 swap_thing (s
->cts_bits
);
1144 /* This has an array of ctf_member or ctf_lmember, depending on
1145 size. We could consider it to be a simple array of uint32_t,
1146 but for safety's sake in case these structures ever acquire
1147 non-uint32_t members, do it member by member. */
1149 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1151 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1153 for (i
= vlen
; i
> 0; i
--, lm
++)
1155 swap_thing (lm
->ctlm_name
);
1156 swap_thing (lm
->ctlm_offsethi
);
1157 swap_thing (lm
->ctlm_type
);
1158 swap_thing (lm
->ctlm_offsetlo
);
1163 ctf_member_t
*m
= (ctf_member_t
*) t
;
1165 for (i
= vlen
; i
> 0; i
--, m
++)
1167 swap_thing (m
->ctm_name
);
1168 swap_thing (m
->ctm_offset
);
1169 swap_thing (m
->ctm_type
);
1177 /* This has an array of ctf_enum_t. */
1179 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1182 for (i
= vlen
; i
> 0; item
++, i
--)
1184 swap_thing (item
->cte_name
);
1185 swap_thing (item
->cte_value
);
1190 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
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_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 (buf
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1220 /* Set up the ctl hashes in a ctf_file_t. Called by both writable and
1221 non-writable dictionary initialization. */
1222 void ctf_set_ctl_hashes (ctf_file_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_file_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_file_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 container 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_dprintf ("ctf_bufopen: CTF version %d symsect not "
1386 "supported\n", pp
->ctp_version
);
1387 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1390 if (pp
->ctp_version
< CTF_VERSION_3
)
1391 hdrsz
= sizeof (ctf_header_v2_t
);
1393 if (ctfsect
->cts_size
< hdrsz
)
1394 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1396 if ((fp
= malloc (sizeof (ctf_file_t
))) == NULL
)
1397 return (ctf_set_open_errno (errp
, ENOMEM
));
1399 memset (fp
, 0, sizeof (ctf_file_t
));
1402 fp
->ctf_flags
|= LCTF_RDWR
;
1404 if ((fp
->ctf_header
= malloc (sizeof (struct ctf_header
))) == NULL
)
1407 return (ctf_set_open_errno (errp
, ENOMEM
));
1409 hp
= fp
->ctf_header
;
1410 memcpy (hp
, ctfsect
->cts_data
, hdrsz
);
1411 if (pp
->ctp_version
< CTF_VERSION_3
)
1412 upgrade_header (hp
);
1416 fp
->ctf_openflags
= hp
->cth_flags
;
1417 fp
->ctf_size
= hp
->cth_stroff
+ hp
->cth_strlen
;
1419 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1420 (unsigned long) fp
->ctf_size
);
1422 if (hp
->cth_lbloff
> fp
->ctf_size
|| hp
->cth_objtoff
> fp
->ctf_size
1423 || hp
->cth_funcoff
> fp
->ctf_size
|| hp
->cth_objtidxoff
> fp
->ctf_size
1424 || hp
->cth_funcidxoff
> fp
->ctf_size
|| hp
->cth_typeoff
> fp
->ctf_size
1425 || hp
->cth_stroff
> fp
->ctf_size
)
1426 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1428 if (hp
->cth_lbloff
> hp
->cth_objtoff
1429 || hp
->cth_objtoff
> hp
->cth_funcoff
1430 || hp
->cth_funcoff
> hp
->cth_typeoff
1431 || hp
->cth_funcoff
> hp
->cth_objtidxoff
1432 || hp
->cth_objtidxoff
> hp
->cth_funcidxoff
1433 || hp
->cth_funcidxoff
> hp
->cth_varoff
1434 || hp
->cth_varoff
> hp
->cth_typeoff
|| hp
->cth_typeoff
> hp
->cth_stroff
)
1435 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1437 if ((hp
->cth_lbloff
& 3) || (hp
->cth_objtoff
& 2)
1438 || (hp
->cth_funcoff
& 2) || (hp
->cth_objtidxoff
& 2)
1439 || (hp
->cth_funcidxoff
& 2) || (hp
->cth_varoff
& 3)
1440 || (hp
->cth_typeoff
& 3))
1441 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1443 /* Once everything is determined to be valid, attempt to decompress the CTF
1444 data buffer if it is compressed, or copy it into new storage if it is not
1445 compressed but needs endian-flipping. Otherwise we just put the data
1446 section's buffer pointer into ctf_buf, below. */
1448 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1451 if (hp
->cth_flags
& CTF_F_COMPRESS
)
1458 /* We are allocating this ourselves, so we can drop the ctf header
1459 copy in favour of ctf->ctf_header. */
1461 if ((fp
->ctf_base
= malloc (fp
->ctf_size
)) == NULL
)
1466 fp
->ctf_dynbase
= fp
->ctf_base
;
1467 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
1469 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1470 srclen
= ctfsect
->cts_size
- hdrsz
;
1471 dstlen
= fp
->ctf_size
;
1472 fp
->ctf_buf
= fp
->ctf_base
;
1474 if ((rc
= uncompress (fp
->ctf_base
, &dstlen
, src
, srclen
)) != Z_OK
)
1476 ctf_dprintf ("zlib inflate err: %s\n", zError (rc
));
1477 err
= ECTF_DECOMPRESS
;
1481 if ((size_t) dstlen
!= fp
->ctf_size
)
1483 ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1484 "bytes\n", (unsigned long) dstlen
,
1485 (unsigned long) fp
->ctf_size
);
1490 else if (foreign_endian
)
1492 if ((fp
->ctf_base
= malloc (fp
->ctf_size
)) == NULL
)
1497 fp
->ctf_dynbase
= fp
->ctf_base
;
1498 memcpy (fp
->ctf_base
, ((unsigned char *) ctfsect
->cts_data
) + hdrsz
,
1500 fp
->ctf_buf
= fp
->ctf_base
;
1504 /* We are just using the section passed in -- but its header may be an old
1505 version. Point ctf_buf past the old header, and never touch it
1507 fp
->ctf_base
= (unsigned char *) ctfsect
->cts_data
;
1508 fp
->ctf_dynbase
= NULL
;
1509 fp
->ctf_buf
= fp
->ctf_base
+ hdrsz
;
1512 /* Once we have uncompressed and validated the CTF data buffer, we can
1513 proceed with initializing the ctf_file_t we allocated above.
1515 Nothing that depends on buf or base should be set directly in this function
1516 before the init_types() call, because it may be reallocated during
1517 transparent upgrade if this recension of libctf is so configured: see
1520 ctf_set_version (fp
, hp
, hp
->cth_version
);
1521 ctf_str_create_atoms (fp
);
1522 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1523 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1525 if (symsect
!= NULL
)
1527 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1528 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1531 if (fp
->ctf_data
.cts_name
!= NULL
)
1532 if ((fp
->ctf_data
.cts_name
= strdup (fp
->ctf_data
.cts_name
)) == NULL
)
1537 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1538 if ((fp
->ctf_symtab
.cts_name
= strdup (fp
->ctf_symtab
.cts_name
)) == NULL
)
1543 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1544 if ((fp
->ctf_strtab
.cts_name
= strdup (fp
->ctf_strtab
.cts_name
)) == NULL
)
1550 if (fp
->ctf_data
.cts_name
== NULL
)
1551 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1552 if (fp
->ctf_symtab
.cts_name
== NULL
)
1553 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1554 if (fp
->ctf_strtab
.cts_name
== NULL
)
1555 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1557 if (strsect
!= NULL
)
1559 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1560 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1562 fp
->ctf_syn_ext_strtab
= syn_strtab
;
1564 if (foreign_endian
&&
1565 (err
= flip_ctf (hp
, fp
->ctf_buf
)) != 0)
1567 /* We can be certain that flip_ctf() will have endian-flipped everything
1568 other than the types table when we return. In particular the header
1569 is fine, so set it, to allow freeing to use the usual code path. */
1571 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1575 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1577 /* No need to do anything else for dynamic containers: they do not support
1578 symbol lookups, and the type table is maintained in the dthashes. */
1579 if (fp
->ctf_flags
& LCTF_RDWR
)
1585 if ((err
= init_types (fp
, hp
)) != 0)
1588 /* If we have a symbol table section, allocate and initialize
1589 the symtab translation table, pointed to by ctf_sxlate. This table may be
1590 too large for the actual size of the object and function info sections: if
1591 so, ctf_nsyms will be adjusted and the excess will never be used. */
1593 if (symsect
!= NULL
)
1595 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1596 fp
->ctf_sxlate
= malloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1598 if (fp
->ctf_sxlate
== NULL
)
1604 if ((err
= init_symtab (fp
, hp
, symsect
, strsect
)) != 0)
1608 ctf_set_ctl_hashes (fp
);
1610 if (symsect
!= NULL
)
1612 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1613 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1615 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1618 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1624 ctf_set_open_errno (errp
, err
);
1625 ctf_file_close (fp
);
1629 /* Close the specified CTF container and free associated data structures. Note
1630 that ctf_file_close() is a reference counted operation: if the specified file
1631 is the parent of other active containers, its reference count will be greater
1632 than one and it will be freed later when no active children exist. */
1635 ctf_file_close (ctf_file_t
*fp
)
1637 ctf_dtdef_t
*dtd
, *ntd
;
1638 ctf_dvdef_t
*dvd
, *nvd
;
1641 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1643 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1645 if (fp
->ctf_refcnt
> 1)
1651 free (fp
->ctf_dyncuname
);
1652 free (fp
->ctf_dynparname
);
1653 ctf_file_close (fp
->ctf_parent
);
1655 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1657 ntd
= ctf_list_next (dtd
);
1658 ctf_dtd_delete (fp
, dtd
);
1660 ctf_dynhash_destroy (fp
->ctf_dthash
);
1661 if (fp
->ctf_flags
& LCTF_RDWR
)
1663 ctf_dynhash_destroy (fp
->ctf_structs
.ctn_writable
);
1664 ctf_dynhash_destroy (fp
->ctf_unions
.ctn_writable
);
1665 ctf_dynhash_destroy (fp
->ctf_enums
.ctn_writable
);
1666 ctf_dynhash_destroy (fp
->ctf_names
.ctn_writable
);
1670 ctf_hash_destroy (fp
->ctf_structs
.ctn_readonly
);
1671 ctf_hash_destroy (fp
->ctf_unions
.ctn_readonly
);
1672 ctf_hash_destroy (fp
->ctf_enums
.ctn_readonly
);
1673 ctf_hash_destroy (fp
->ctf_names
.ctn_readonly
);
1676 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1678 nvd
= ctf_list_next (dvd
);
1679 ctf_dvd_delete (fp
, dvd
);
1681 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1682 ctf_str_free_atoms (fp
);
1683 free (fp
->ctf_tmp_typeslice
);
1685 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
)
1686 free ((char *) fp
->ctf_data
.cts_name
);
1688 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
)
1689 free ((char *) fp
->ctf_symtab
.cts_name
);
1691 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
)
1692 free ((char *) fp
->ctf_strtab
.cts_name
);
1693 else if (fp
->ctf_data_mmapped
)
1694 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1696 free (fp
->ctf_dynbase
);
1698 ctf_dynhash_destroy (fp
->ctf_syn_ext_strtab
);
1699 ctf_dynhash_destroy (fp
->ctf_link_inputs
);
1700 ctf_dynhash_destroy (fp
->ctf_link_outputs
);
1701 ctf_dynhash_destroy (fp
->ctf_link_type_mapping
);
1702 ctf_dynhash_destroy (fp
->ctf_link_cu_mapping
);
1703 ctf_dynhash_destroy (fp
->ctf_add_processing
);
1705 free (fp
->ctf_sxlate
);
1706 free (fp
->ctf_txlate
);
1707 free (fp
->ctf_ptrtab
);
1709 free (fp
->ctf_header
);
1713 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1714 archive, so closing one is just like closing an archive. */
1716 ctf_close (ctf_archive_t
*arc
)
1718 ctf_arc_close (arc
);
1721 /* Get the CTF archive from which this ctf_file_t is derived. */
1723 ctf_get_arc (const ctf_file_t
*fp
)
1725 return fp
->ctf_archive
;
1728 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1729 ctfsect's data * after ctf_file_close(), which is why we return the actual
1730 structure, not a pointer to it, since that is likely to become a pointer to
1731 freed data before the return value is used under the expected use case of
1732 ctf_getsect()/ ctf_file_close()/free(). */
1734 ctf_getdatasect (const ctf_file_t
*fp
)
1736 return fp
->ctf_data
;
1739 /* Return the CTF handle for the parent CTF container, if one exists.
1740 Otherwise return NULL to indicate this container has no imported parent. */
1742 ctf_parent_file (ctf_file_t
*fp
)
1744 return fp
->ctf_parent
;
1747 /* Return the name of the parent CTF container, if one exists. Otherwise
1748 return NULL to indicate this container is a root container. */
1750 ctf_parent_name (ctf_file_t
*fp
)
1752 return fp
->ctf_parname
;
1755 /* Set the parent name. It is an error to call this routine without calling
1756 ctf_import() at some point. */
1758 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1760 if (fp
->ctf_dynparname
!= NULL
)
1761 free (fp
->ctf_dynparname
);
1763 if ((fp
->ctf_dynparname
= strdup (name
)) == NULL
)
1764 return (ctf_set_errno (fp
, ENOMEM
));
1765 fp
->ctf_parname
= fp
->ctf_dynparname
;
1769 /* Return the name of the compilation unit this CTF file applies to. Usually
1770 non-NULL only for non-parent containers. */
1772 ctf_cuname (ctf_file_t
*fp
)
1774 return fp
->ctf_cuname
;
1777 /* Set the compilation unit name. */
1779 ctf_cuname_set (ctf_file_t
*fp
, const char *name
)
1781 if (fp
->ctf_dyncuname
!= NULL
)
1782 free (fp
->ctf_dyncuname
);
1784 if ((fp
->ctf_dyncuname
= strdup (name
)) == NULL
)
1785 return (ctf_set_errno (fp
, ENOMEM
));
1786 fp
->ctf_cuname
= fp
->ctf_dyncuname
;
1790 /* Import the types from the specified parent container by storing a pointer
1791 to it in ctf_parent and incrementing its reference count. Only one parent
1792 is allowed: if a parent already exists, it is replaced by the new parent. */
1794 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1796 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1797 return (ctf_set_errno (fp
, EINVAL
));
1799 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1800 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1802 if (fp
->ctf_parent
!= NULL
)
1804 fp
->ctf_parent
->ctf_refcnt
--;
1805 ctf_file_close (fp
->ctf_parent
);
1806 fp
->ctf_parent
= NULL
;
1813 if (fp
->ctf_parname
== NULL
)
1814 if ((err
= ctf_parent_name_set (fp
, "PARENT")) < 0)
1817 fp
->ctf_flags
|= LCTF_CHILD
;
1821 fp
->ctf_parent
= pfp
;
1825 /* Set the data model constant for the CTF container. */
1827 ctf_setmodel (ctf_file_t
*fp
, int model
)
1829 const ctf_dmodel_t
*dp
;
1831 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1833 if (dp
->ctd_code
== model
)
1835 fp
->ctf_dmodel
= dp
;
1840 return (ctf_set_errno (fp
, EINVAL
));
1843 /* Return the data model constant for the CTF container. */
1845 ctf_getmodel (ctf_file_t
*fp
)
1847 return fp
->ctf_dmodel
->ctd_code
;
1850 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1853 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1855 fp
->ctf_specific
= data
;
1858 /* Retrieve the arbitrary pointer again. */
1860 ctf_getspecific (ctf_file_t
*fp
)
1862 return fp
->ctf_specific
;