2 Copyright (C) 2019 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_typeoff
)
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_funcoff
= oldhp
->cth_funcoff
;
380 hp
->cth_objtoff
= oldhp
->cth_objtoff
;
381 hp
->cth_lbloff
= oldhp
->cth_lbloff
;
382 hp
->cth_cuname
= 0; /* No CU name. */
385 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3)
388 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
389 not be called before reallocation is complete.
391 Type kinds not checked here due to nonexistence in older formats:
394 upgrade_types_v1 (ctf_file_t
*fp
, ctf_header_t
*cth
)
396 const ctf_type_v1_t
*tbuf
;
397 const ctf_type_v1_t
*tend
;
398 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_dynbase
;
401 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
402 const ctf_type_v1_t
*tp
;
405 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
406 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
408 /* Much like init_types(), this is a two-pass process.
410 First, figure out the new type-section size needed. (It is possible,
411 in theory, for it to be less than the old size, but this is very
412 unlikely. It cannot be so small that cth_typeoff ends up of negative
413 size. We validate this with an assertion below.)
415 We must cater not only for changes in vlen and types sizes but also
416 for changes in 'increment', which happen because v2 places some types
417 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
419 for (tp
= tbuf
; tp
< tend
;
420 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
422 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
423 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
425 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
426 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
428 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
430 v2bytes
= get_vbytes_v2 (kind
, size
, vlen
);
432 if ((vbytes
< 0) || (size
< 0))
435 increase
+= v2increment
- increment
; /* May be negative. */
436 increase
+= v2bytes
- vbytes
;
439 /* Allocate enough room for the new buffer, then copy everything but the type
440 section into place, and reset the base accordingly. Leave the version
441 number unchanged, so that LCTF_INFO_* still works on the
442 as-yet-untranslated type info. */
444 if ((ctf_base
= ctf_alloc (fp
->ctf_size
+ increase
)) == NULL
)
447 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
448 never use it and it is unconverted. */
450 memcpy (ctf_base
, fp
->ctf_buf
, cth
->cth_typeoff
);
451 memcpy (ctf_base
+ cth
->cth_stroff
+ increase
,
452 fp
->ctf_buf
+ cth
->cth_stroff
, cth
->cth_strlen
);
454 memset (ctf_base
+ cth
->cth_typeoff
, 0, cth
->cth_stroff
- cth
->cth_typeoff
457 cth
->cth_stroff
+= increase
;
458 fp
->ctf_size
+= increase
;
459 assert (cth
->cth_stroff
>= cth
->cth_typeoff
);
460 fp
->ctf_base
= ctf_base
;
461 fp
->ctf_buf
= ctf_base
;
462 fp
->ctf_dynbase
= ctf_base
;
463 ctf_set_base (fp
, cth
, ctf_base
);
465 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
467 /* Iterate through all the types again, upgrading them.
469 Everything that hasn't changed can just be outright memcpy()ed.
470 Things that have changed need field-by-field consideration. */
472 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
473 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
474 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
476 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
477 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
478 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
480 void *vdata
, *v2data
;
482 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
483 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
485 t2p
->ctt_name
= tp
->ctt_name
;
486 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
497 t2p
->ctt_type
= tp
->ctt_type
;
506 if ((size_t) size
<= CTF_MAX_SIZE
)
507 t2p
->ctt_size
= size
;
510 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
511 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
516 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
517 v2bytes
= get_vbytes_v2 (kind
, v2size
, vlen
);
519 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
520 these are not identical (and having them different makes no
521 sense semantically). */
523 assert (size
== v2size
);
525 /* Now the varlen info. */
527 vdata
= (void *) ((uintptr_t) tp
+ increment
);
528 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
534 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
535 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
537 a2p
->cta_contents
= ap
->cta_contents
;
538 a2p
->cta_index
= ap
->cta_index
;
539 a2p
->cta_nelems
= ap
->cta_nelems
;
546 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
547 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
548 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
549 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
552 /* We walk all four pointers forward, but only reference the two
553 that are valid for the given size, to avoid quadruplicating all
556 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
559 if (size
< CTF_LSTRUCT_THRESH_V1
)
561 offset
= m1
->ctm_offset
;
562 tmp
.ctm_name
= m1
->ctm_name
;
563 tmp
.ctm_type
= m1
->ctm_type
;
567 offset
= CTF_LMEM_OFFSET (lm1
);
568 tmp
.ctm_name
= lm1
->ctlm_name
;
569 tmp
.ctm_type
= lm1
->ctlm_type
;
571 if (size
< CTF_LSTRUCT_THRESH
)
573 m2
->ctm_name
= tmp
.ctm_name
;
574 m2
->ctm_type
= tmp
.ctm_type
;
575 m2
->ctm_offset
= offset
;
579 lm2
->ctlm_name
= tmp
.ctm_name
;
580 lm2
->ctlm_type
= tmp
.ctm_type
;
581 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
582 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
590 unsigned short *a1
= (unsigned short *) vdata
;
591 uint32_t *a2
= (uint32_t *) v2data
;
593 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
598 /* Catch out-of-sync get_vbytes_*(). */
599 assert (vbytes
== v2bytes
);
600 memcpy (v2data
, vdata
, vbytes
);
604 /* Verify that the entire region was converted. If not, we are either
605 converting too much, or too little (leading to a buffer overrun either here
606 or at read time, in init_types().) */
608 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== cth
->cth_stroff
);
610 ctf_set_version (fp
, cth
, CTF_VERSION_1_UPGRADED_3
);
611 ctf_free (old_ctf_base
);
616 /* Upgrade from any earlier version. */
618 upgrade_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
620 switch (cth
->cth_version
)
622 /* v1 requires a full pass and reformatting. */
624 upgrade_types_v1 (fp
, cth
);
626 /* Already-converted v1 is just like later versions except that its
627 parent/child boundary is unchanged (and much lower). */
629 case CTF_VERSION_1_UPGRADED_3
:
630 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
632 /* v2 is just the same as v3 except for new types and sections:
633 no upgrading required. */
634 case CTF_VERSION_2
: ;
640 /* Initialize the type ID translation table with the byte offset of each type,
641 and initialize the hash tables of each named type. Upgrade the type table to
642 the latest supported representation in the process, if needed, and if this
643 recension of libctf supports upgrading. */
646 init_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
648 const ctf_type_t
*tbuf
;
649 const ctf_type_t
*tend
;
651 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
652 const ctf_type_t
*tp
;
657 /* We determine whether the container is a child or a parent based on
658 the value of cth_parname. */
660 int child
= cth
->cth_parname
!= 0;
661 int nlstructs
= 0, nlunions
= 0;
664 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
667 if ((err
= upgrade_types (fp
, cth
)) != 0)
668 return err
; /* Upgrade failed. */
671 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
672 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
674 /* We make two passes through the entire type section. In this first
675 pass, we count the number of each type and the total number of types. */
677 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
679 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
680 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
681 ssize_t size
, increment
, vbytes
;
683 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
684 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
689 if (kind
== CTF_K_FORWARD
)
691 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
692 so bump that population count too. If ctt_type is unknown, treat
693 the tag as a struct. */
695 if (tp
->ctt_type
== CTF_K_UNKNOWN
|| tp
->ctt_type
>= CTF_K_MAX
)
700 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
706 ctf_dprintf ("CTF container %p is a child\n", (void *) fp
);
707 fp
->ctf_flags
|= LCTF_CHILD
;
710 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp
);
712 /* Now that we've counted up the number of each type, we can allocate
713 the hash tables, type translation table, and pointer table. */
715 if ((fp
->ctf_structs
= ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
716 ctf_hash_eq_string
)) == NULL
)
719 if ((fp
->ctf_unions
= ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
720 ctf_hash_eq_string
)) == NULL
)
723 if ((fp
->ctf_enums
= ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
724 ctf_hash_eq_string
)) == NULL
)
727 if ((fp
->ctf_names
= ctf_hash_create (pop
[CTF_K_INTEGER
] +
729 pop
[CTF_K_FUNCTION
] +
732 pop
[CTF_K_VOLATILE
] +
736 ctf_hash_eq_string
)) == NULL
)
739 fp
->ctf_txlate
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
740 fp
->ctf_ptrtab
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
742 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
743 return ENOMEM
; /* Memory allocation failed. */
746 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
748 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
749 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
751 /* In the second pass through the types, we fill in each entry of the
752 type and pointer tables and add names to the appropriate hashes. */
754 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
756 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
757 unsigned short flag
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
758 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
759 ssize_t size
, increment
, vbytes
;
763 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
764 name
= ctf_strptr (fp
, tp
->ctt_name
);
765 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
771 /* Names are reused by bit-fields, which are differentiated by their
772 encodings, and so typically we'd record only the first instance of
773 a given intrinsic. However, we replace an existing type with a
774 root-visible version so that we can be sure to find it when
775 checking for conflicting definitions in ctf_add_type(). */
777 if (((ctf_hash_lookup_type (fp
->ctf_names
, fp
, name
)) == 0)
778 || (flag
& CTF_ADD_ROOT
))
780 err
= ctf_hash_define_type (fp
->ctf_names
, fp
,
781 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
783 if (err
!= 0 && err
!= ECTF_STRTAB
)
788 /* These kinds have no name, so do not need interning into any
795 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
796 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
798 if (err
!= 0 && err
!= ECTF_STRTAB
)
803 err
= ctf_hash_define_type (fp
->ctf_structs
, fp
,
804 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
807 if (err
!= 0 && err
!= ECTF_STRTAB
)
810 if (size
>= CTF_LSTRUCT_THRESH
)
815 err
= ctf_hash_define_type (fp
->ctf_unions
, fp
,
816 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
819 if (err
!= 0 && err
!= ECTF_STRTAB
)
822 if (size
>= CTF_LSTRUCT_THRESH
)
827 err
= ctf_hash_define_type (fp
->ctf_enums
, fp
,
828 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
831 if (err
!= 0 && err
!= ECTF_STRTAB
)
836 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
837 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
839 if (err
!= 0 && err
!= ECTF_STRTAB
)
844 /* Only insert forward tags into the given hash if the type or tag
845 name is not already present. */
846 switch (tp
->ctt_type
)
849 hp
= fp
->ctf_structs
;
858 hp
= fp
->ctf_structs
;
861 if (ctf_hash_lookup_type (hp
, fp
, name
) == 0)
863 err
= ctf_hash_insert_type (hp
, fp
,
864 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
866 if (err
!= 0 && err
!= ECTF_STRTAB
)
872 /* If the type referenced by the pointer is in this CTF container,
873 then store the index of the pointer type in
874 fp->ctf_ptrtab[ index of referenced type ]. */
876 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
877 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
878 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
884 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
885 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
887 if (err
!= 0 && err
!= ECTF_STRTAB
)
891 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
896 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
897 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
900 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
901 ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp
->ctf_enums
));
902 ctf_dprintf ("%u struct names hashed (%d long)\n",
903 ctf_hash_size (fp
->ctf_structs
), nlstructs
);
904 ctf_dprintf ("%u union names hashed (%d long)\n",
905 ctf_hash_size (fp
->ctf_unions
), nlunions
);
906 ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp
->ctf_names
));
908 /* Make an additional pass through the pointer table to find pointers that
909 point to anonymous typedef nodes. If we find one, modify the pointer table
910 so that the pointer is also known to point to the node that is referenced
911 by the anonymous typedef node. */
913 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
915 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
917 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
919 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
&&
920 strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0 &&
921 LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
&&
922 LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
923 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
930 /* Endianness-flipping routines.
932 We flip everything, mindlessly, even 1-byte entities, so that future
933 expansions do not require changes to this code. */
935 /* < C11? define away static assertions. */
937 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
938 #define _Static_assert(cond, err)
941 /* Swap the endianness of something. */
943 #define swap_thing(x) \
945 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
946 && sizeof (x) <= 8), \
947 "Invalid size, update endianness code"); \
948 switch (sizeof (x)) { \
949 case 2: x = bswap_16 (x); break; \
950 case 4: x = bswap_32 (x); break; \
951 case 8: x = bswap_64 (x); break; \
952 case 1: /* Nothing needs doing */ \
957 /* Flip the endianness of the CTF header. */
960 flip_header (ctf_header_t
*cth
)
962 swap_thing (cth
->cth_preamble
.ctp_magic
);
963 swap_thing (cth
->cth_preamble
.ctp_version
);
964 swap_thing (cth
->cth_preamble
.ctp_flags
);
965 swap_thing (cth
->cth_parlabel
);
966 swap_thing (cth
->cth_parname
);
967 swap_thing (cth
->cth_cuname
);
968 swap_thing (cth
->cth_objtoff
);
969 swap_thing (cth
->cth_funcoff
);
970 swap_thing (cth
->cth_varoff
);
971 swap_thing (cth
->cth_typeoff
);
972 swap_thing (cth
->cth_stroff
);
973 swap_thing (cth
->cth_strlen
);
976 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
979 flip_lbls (void *start
, size_t len
)
981 ctf_lblent_t
*lbl
= start
;
983 for (ssize_t i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
985 swap_thing (lbl
->ctl_label
);
986 swap_thing (lbl
->ctl_type
);
990 /* Flip the endianness of the data-object or function sections, an array of
991 uint32_t. (The function section has more internal structure, but that
992 structure is an array of uint32_t, so can be treated as one big array for
996 flip_objts (void *start
, size_t len
)
998 uint32_t *obj
= start
;
1000 for (ssize_t i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
1004 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
1007 flip_vars (void *start
, size_t len
)
1009 ctf_varent_t
*var
= start
;
1011 for (ssize_t i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
1013 swap_thing (var
->ctv_name
);
1014 swap_thing (var
->ctv_type
);
1018 /* Flip the endianness of the type section, a tagged array of ctf_type or
1019 ctf_stype followed by variable data. */
1022 flip_types (void *start
, size_t len
)
1024 ctf_type_t
*t
= start
;
1026 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
1028 swap_thing (t
->ctt_name
);
1029 swap_thing (t
->ctt_info
);
1030 swap_thing (t
->ctt_size
);
1032 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1033 size_t size
= t
->ctt_size
;
1034 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1035 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1037 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1039 swap_thing (t
->ctt_lsizehi
);
1040 swap_thing (t
->ctt_lsizelo
);
1041 size
= CTF_TYPE_LSIZE (t
);
1042 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1045 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1053 case CTF_K_VOLATILE
:
1055 case CTF_K_RESTRICT
:
1056 /* These types have no vlen data to swap. */
1057 assert (vbytes
== 0);
1063 /* These types have a single uint32_t. */
1065 uint32_t *item
= (uint32_t *) t
;
1071 case CTF_K_FUNCTION
:
1073 /* This type has a bunch of uint32_ts. */
1075 uint32_t *item
= (uint32_t *) t
;
1077 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1084 /* This has a single ctf_array_t. */
1086 ctf_array_t
*a
= (ctf_array_t
*) t
;
1088 assert (vbytes
== sizeof (ctf_array_t
));
1089 swap_thing (a
->cta_contents
);
1090 swap_thing (a
->cta_index
);
1091 swap_thing (a
->cta_nelems
);
1098 /* This has a single ctf_slice_t. */
1100 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1102 assert (vbytes
== sizeof (ctf_slice_t
));
1103 swap_thing (s
->cts_type
);
1104 swap_thing (s
->cts_offset
);
1105 swap_thing (s
->cts_bits
);
1113 /* This has an array of ctf_member or ctf_lmember, depending on
1114 size. We could consider it to be a simple array of uint32_t,
1115 but for safety's sake in case these structures ever acquire
1116 non-uint32_t members, do it member by member. */
1118 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1120 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1121 for (ssize_t i
= vlen
; i
> 0; i
--, lm
++)
1123 swap_thing (lm
->ctlm_name
);
1124 swap_thing (lm
->ctlm_offsethi
);
1125 swap_thing (lm
->ctlm_type
);
1126 swap_thing (lm
->ctlm_offsetlo
);
1131 ctf_member_t
*m
= (ctf_member_t
*) t
;
1132 for (ssize_t i
= vlen
; i
> 0; i
--, m
++)
1134 swap_thing (m
->ctm_name
);
1135 swap_thing (m
->ctm_offset
);
1136 swap_thing (m
->ctm_type
);
1144 /* This has an array of ctf_enum_t. */
1146 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1148 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1150 swap_thing (item
->cte_name
);
1151 swap_thing (item
->cte_value
);
1156 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1158 return ECTF_CORRUPT
;
1161 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1167 /* Flip the endianness of BUF, given the offsets in the (already endian-
1170 All of this stuff happens before the header is fully initialized, so the
1171 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1172 data, this is no real loss. */
1175 flip_ctf (ctf_header_t
*cth
, unsigned char *buf
)
1177 flip_lbls (buf
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1178 flip_objts (buf
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1179 flip_objts (buf
+ cth
->cth_funcoff
, cth
->cth_varoff
- cth
->cth_funcoff
);
1180 flip_vars (buf
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1181 return flip_types (buf
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1184 /* Open a CTF file, mocking up a suitable ctf_sect. */
1185 ctf_file_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1186 const char *symsect
, size_t symsect_size
,
1187 size_t symsect_entsize
,
1188 const char *strsect
, size_t strsect_size
,
1191 ctf_sect_t skeleton
;
1193 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1194 ctf_sect_t
*ctfsectp
= NULL
;
1195 ctf_sect_t
*symsectp
= NULL
;
1196 ctf_sect_t
*strsectp
= NULL
;
1198 skeleton
.cts_name
= _CTF_SECTION
;
1199 skeleton
.cts_entsize
= 1;
1203 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1204 ctf_sect
.cts_data
= ctfsect
;
1205 ctf_sect
.cts_size
= ctfsect_size
;
1206 ctfsectp
= &ctf_sect
;
1211 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1212 sym_sect
.cts_data
= symsect
;
1213 sym_sect
.cts_size
= symsect_size
;
1214 sym_sect
.cts_entsize
= symsect_entsize
;
1215 symsectp
= &sym_sect
;
1220 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1221 str_sect
.cts_data
= strsect
;
1222 str_sect
.cts_size
= strsect_size
;
1223 strsectp
= &str_sect
;
1226 return ctf_bufopen (ctfsectp
, symsectp
, strsectp
, errp
);
1229 /* Decode the specified CTF buffer and optional symbol table, and create a new
1230 CTF container representing the symbolic debugging information. This code can
1231 be used directly by the debugger, or it can be used as the engine for
1232 ctf_fdopen() or ctf_open(), below. */
1235 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1236 const ctf_sect_t
*strsect
, int *errp
)
1238 const ctf_preamble_t
*pp
;
1239 size_t hdrsz
= sizeof (ctf_header_t
);
1242 int foreign_endian
= 0;
1245 libctf_init_debug();
1247 if (ctfsect
== NULL
|| ((symsect
== NULL
) != (strsect
== NULL
)))
1248 return (ctf_set_open_errno (errp
, EINVAL
));
1250 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1251 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1252 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1254 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1255 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1257 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1258 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1260 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1261 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1263 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1265 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1266 pp
->ctp_magic
, pp
->ctp_version
);
1268 /* Validate each part of the CTF header.
1270 First, we validate the preamble (common to all versions). At that point,
1271 we know the endianness and specific header version, and can validate the
1272 version-specific parts including section offsets and alignments.
1274 We specifically do not support foreign-endian old versions. */
1276 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1278 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1280 if (pp
->ctp_version
!= CTF_VERSION_3
)
1281 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1285 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1288 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1289 || (pp
->ctp_version
> CTF_VERSION_3
)))
1290 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1292 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1294 /* The symtab can contain function entries which contain embedded ctf
1295 info. We do not support dynamically upgrading such entries (none
1296 should exist in any case, since dwarf2ctf does not create them). */
1298 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1299 "supported\n", pp
->ctp_version
);
1300 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1303 if (pp
->ctp_version
< CTF_VERSION_3
)
1304 hdrsz
= sizeof (ctf_header_v2_t
);
1306 if (ctfsect
->cts_size
< hdrsz
)
1307 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1309 if ((fp
= ctf_alloc (sizeof (ctf_file_t
))) == NULL
)
1310 return (ctf_set_open_errno (errp
, ENOMEM
));
1312 memset (fp
, 0, sizeof (ctf_file_t
));
1314 if ((fp
->ctf_header
= ctf_alloc (sizeof (struct ctf_header
))) == NULL
)
1317 return (ctf_set_open_errno (errp
, ENOMEM
));
1319 hp
= fp
->ctf_header
;
1320 memcpy (hp
, ctfsect
->cts_data
, hdrsz
);
1321 if (pp
->ctp_version
< CTF_VERSION_3
)
1322 upgrade_header (hp
);
1326 fp
->ctf_openflags
= hp
->cth_flags
;
1327 fp
->ctf_size
= hp
->cth_stroff
+ hp
->cth_strlen
;
1329 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n",
1330 (unsigned long) fp
->ctf_size
);
1332 if (hp
->cth_lbloff
> fp
->ctf_size
|| hp
->cth_objtoff
> fp
->ctf_size
1333 || hp
->cth_funcoff
> fp
->ctf_size
|| hp
->cth_typeoff
> fp
->ctf_size
1334 || hp
->cth_stroff
> fp
->ctf_size
)
1335 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1337 if (hp
->cth_lbloff
> hp
->cth_objtoff
1338 || hp
->cth_objtoff
> hp
->cth_funcoff
1339 || hp
->cth_funcoff
> hp
->cth_typeoff
1340 || hp
->cth_funcoff
> hp
->cth_varoff
1341 || hp
->cth_varoff
> hp
->cth_typeoff
|| hp
->cth_typeoff
> hp
->cth_stroff
)
1342 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1344 if ((hp
->cth_lbloff
& 3) || (hp
->cth_objtoff
& 2)
1345 || (hp
->cth_funcoff
& 2) || (hp
->cth_varoff
& 3)
1346 || (hp
->cth_typeoff
& 3))
1347 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1349 /* Once everything is determined to be valid, attempt to decompress the CTF
1350 data buffer if it is compressed, or copy it into new storage if it is not
1351 compressed but needs endian-flipping. Otherwise we just put the data
1352 section's buffer pointer into ctf_buf, below. */
1354 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1357 if (hp
->cth_flags
& CTF_F_COMPRESS
)
1364 /* We are allocating this ourselves, so we can drop the ctf header
1365 copy in favour of ctf->ctf_header. */
1367 if ((fp
->ctf_base
= ctf_alloc (fp
->ctf_size
)) == NULL
)
1372 fp
->ctf_dynbase
= fp
->ctf_base
;
1373 hp
->cth_flags
&= ~CTF_F_COMPRESS
;
1375 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1376 srclen
= ctfsect
->cts_size
- hdrsz
;
1377 dstlen
= fp
->ctf_size
;
1378 fp
->ctf_buf
= fp
->ctf_base
;
1380 if ((rc
= uncompress (fp
->ctf_base
, &dstlen
, src
, srclen
)) != Z_OK
)
1382 ctf_dprintf ("zlib inflate err: %s\n", zError (rc
));
1383 err
= ECTF_DECOMPRESS
;
1387 if ((size_t) dstlen
!= fp
->ctf_size
)
1389 ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1390 "bytes\n", (unsigned long) dstlen
,
1391 (unsigned long) fp
->ctf_size
);
1396 else if (foreign_endian
)
1398 if ((fp
->ctf_base
= ctf_alloc (fp
->ctf_size
)) == NULL
)
1403 fp
->ctf_dynbase
= fp
->ctf_base
;
1404 memcpy (fp
->ctf_base
, ((unsigned char *) ctfsect
->cts_data
) + hdrsz
,
1406 fp
->ctf_buf
= fp
->ctf_base
;
1410 /* We are just using the section passed in -- but its header may be an old
1411 version. Point ctf_buf past the old header, and never touch it
1413 fp
->ctf_base
= (unsigned char *) ctfsect
->cts_data
;
1414 fp
->ctf_dynbase
= NULL
;
1415 fp
->ctf_buf
= fp
->ctf_base
+ hdrsz
;
1418 /* Once we have uncompressed and validated the CTF data buffer, we can
1419 proceed with initializing the ctf_file_t we allocated above.
1421 Nothing that depends on buf or base should be set directly in this function
1422 before the init_types() call, because it may be reallocated during
1423 transparent upgrade if this recension of libctf is so configured: see
1426 ctf_set_version (fp
, hp
, hp
->cth_version
);
1427 ctf_str_create_atoms (fp
);
1428 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1429 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1431 if (symsect
!= NULL
)
1433 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1434 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1437 if (fp
->ctf_data
.cts_name
!= NULL
)
1438 fp
->ctf_data
.cts_name
= ctf_strdup (fp
->ctf_data
.cts_name
);
1439 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1440 fp
->ctf_symtab
.cts_name
= ctf_strdup (fp
->ctf_symtab
.cts_name
);
1441 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1442 fp
->ctf_strtab
.cts_name
= ctf_strdup (fp
->ctf_strtab
.cts_name
);
1444 if (fp
->ctf_data
.cts_name
== NULL
)
1445 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1446 if (fp
->ctf_symtab
.cts_name
== NULL
)
1447 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1448 if (fp
->ctf_strtab
.cts_name
== NULL
)
1449 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1451 if (strsect
!= NULL
)
1453 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1454 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1457 if (foreign_endian
&&
1458 (err
= flip_ctf (hp
, fp
->ctf_buf
)) != 0)
1460 /* We can be certain that flip_ctf() will have endian-flipped everything
1461 other than the types table when we return. In particular the header
1462 is fine, so set it, to allow freeing to use the usual code path. */
1464 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1468 ctf_set_base (fp
, hp
, fp
->ctf_base
);
1470 if ((err
= init_types (fp
, hp
)) != 0)
1473 /* If we have a symbol table section, allocate and initialize
1474 the symtab translation table, pointed to by ctf_sxlate. This table may be
1475 too large for the actual size of the object and function info sections: if
1476 so, ctf_nsyms will be adjusted and the excess will never be used. */
1478 if (symsect
!= NULL
)
1480 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1481 fp
->ctf_sxlate
= ctf_alloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1483 if (fp
->ctf_sxlate
== NULL
)
1489 if ((err
= init_symtab (fp
, hp
, symsect
, strsect
)) != 0)
1493 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1494 array of type name prefixes and the corresponding ctf_hash to use.
1495 NOTE: This code must be kept in sync with the code in ctf_update(). */
1496 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1497 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1498 fp
->ctf_lookups
[0].ctl_hash
= fp
->ctf_structs
;
1499 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1500 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1501 fp
->ctf_lookups
[1].ctl_hash
= fp
->ctf_unions
;
1502 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1503 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1504 fp
->ctf_lookups
[2].ctl_hash
= fp
->ctf_enums
;
1505 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1506 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1507 fp
->ctf_lookups
[3].ctl_hash
= fp
->ctf_names
;
1508 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1509 fp
->ctf_lookups
[4].ctl_len
= 0;
1510 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1512 if (symsect
!= NULL
)
1514 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1515 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1517 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1520 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1526 ctf_set_open_errno (errp
, err
);
1527 ctf_file_close (fp
);
1531 /* Close the specified CTF container and free associated data structures. Note
1532 that ctf_file_close() is a reference counted operation: if the specified file
1533 is the parent of other active containers, its reference count will be greater
1534 than one and it will be freed later when no active children exist. */
1537 ctf_file_close (ctf_file_t
*fp
)
1539 ctf_dtdef_t
*dtd
, *ntd
;
1540 ctf_dvdef_t
*dvd
, *nvd
;
1543 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1545 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1547 if (fp
->ctf_refcnt
> 1)
1553 ctf_free (fp
->ctf_dyncuname
);
1554 ctf_free (fp
->ctf_dynparname
);
1555 ctf_file_close (fp
->ctf_parent
);
1557 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1559 ntd
= ctf_list_next (dtd
);
1560 ctf_dtd_delete (fp
, dtd
);
1562 ctf_dynhash_destroy (fp
->ctf_dthash
);
1563 ctf_dynhash_destroy (fp
->ctf_dtbyname
);
1565 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1567 nvd
= ctf_list_next (dvd
);
1568 ctf_dvd_delete (fp
, dvd
);
1570 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1571 ctf_str_free_atoms (fp
);
1572 ctf_free (fp
->ctf_tmp_typeslice
);
1574 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
)
1575 ctf_free ((char *) fp
->ctf_data
.cts_name
);
1577 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
)
1578 ctf_free ((char *) fp
->ctf_symtab
.cts_name
);
1580 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
)
1581 ctf_free ((char *) fp
->ctf_strtab
.cts_name
);
1583 else if (fp
->ctf_data_mmapped
)
1584 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1586 ctf_free (fp
->ctf_dynbase
);
1588 ctf_free (fp
->ctf_sxlate
);
1589 ctf_free (fp
->ctf_txlate
);
1590 ctf_free (fp
->ctf_ptrtab
);
1592 ctf_hash_destroy (fp
->ctf_structs
);
1593 ctf_hash_destroy (fp
->ctf_unions
);
1594 ctf_hash_destroy (fp
->ctf_enums
);
1595 ctf_hash_destroy (fp
->ctf_names
);
1597 ctf_free (fp
->ctf_header
);
1601 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1602 archive, so closing one is just like closing an archive. */
1604 ctf_close (ctf_archive_t
*arc
)
1606 ctf_arc_close (arc
);
1609 /* Get the CTF archive from which this ctf_file_t is derived. */
1611 ctf_get_arc (const ctf_file_t
*fp
)
1613 return fp
->ctf_archive
;
1616 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1617 ctfsect's data * after ctf_file_close(), which is why we return the actual
1618 structure, not a pointer to it, since that is likely to become a pointer to
1619 freed data before the return value is used under the expected use case of
1620 ctf_getsect()/ ctf_file_close()/free(). */
1622 ctf_getdatasect (const ctf_file_t
*fp
)
1624 return fp
->ctf_data
;
1627 /* Return the CTF handle for the parent CTF container, if one exists.
1628 Otherwise return NULL to indicate this container has no imported parent. */
1630 ctf_parent_file (ctf_file_t
*fp
)
1632 return fp
->ctf_parent
;
1635 /* Return the name of the parent CTF container, if one exists. Otherwise
1636 return NULL to indicate this container is a root container. */
1638 ctf_parent_name (ctf_file_t
*fp
)
1640 return fp
->ctf_parname
;
1643 /* Set the parent name. It is an error to call this routine without calling
1644 ctf_import() at some point. */
1646 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1648 if (fp
->ctf_dynparname
!= NULL
)
1649 ctf_free (fp
->ctf_dynparname
);
1651 fp
->ctf_dynparname
= ctf_strdup (name
);
1652 fp
->ctf_parname
= fp
->ctf_dynparname
;
1655 /* Return the name of the compilation unit this CTF file applies to. Usually
1656 non-NULL only for non-parent containers. */
1658 ctf_cuname (ctf_file_t
*fp
)
1660 return fp
->ctf_cuname
;
1663 /* Set the compilation unit name. */
1665 ctf_cuname_set (ctf_file_t
*fp
, const char *name
)
1667 if (fp
->ctf_dyncuname
!= NULL
)
1668 ctf_free (fp
->ctf_dyncuname
);
1670 fp
->ctf_dyncuname
= ctf_strdup (name
);
1671 fp
->ctf_cuname
= fp
->ctf_dyncuname
;
1674 /* Import the types from the specified parent container by storing a pointer
1675 to it in ctf_parent and incrementing its reference count. Only one parent
1676 is allowed: if a parent already exists, it is replaced by the new parent. */
1678 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1680 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1681 return (ctf_set_errno (fp
, EINVAL
));
1683 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1684 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1686 if (fp
->ctf_parent
!= NULL
)
1687 ctf_file_close (fp
->ctf_parent
);
1691 fp
->ctf_flags
|= LCTF_CHILD
;
1694 if (fp
->ctf_parname
== NULL
)
1695 ctf_parent_name_set (fp
, "PARENT");
1697 fp
->ctf_parent
= pfp
;
1701 /* Set the data model constant for the CTF container. */
1703 ctf_setmodel (ctf_file_t
*fp
, int model
)
1705 const ctf_dmodel_t
*dp
;
1707 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1709 if (dp
->ctd_code
== model
)
1711 fp
->ctf_dmodel
= dp
;
1716 return (ctf_set_errno (fp
, EINVAL
));
1719 /* Return the data model constant for the CTF container. */
1721 ctf_getmodel (ctf_file_t
*fp
)
1723 return fp
->ctf_dmodel
->ctd_code
;
1726 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1729 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1731 fp
->ctf_specific
= data
;
1734 /* Retrieve the arbitrary pointer again. */
1736 ctf_getspecific (ctf_file_t
*fp
)
1738 return fp
->ctf_specific
;