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 (offsetof (ctf_slice_t
, cts_bits
) +
154 sizeof (((ctf_slice_t
*)0)->cts_bits
));
156 return (sizeof (ctf_enum_t
) * vlen
);
166 ctf_dprintf ("detected invalid CTF kind -- %x\n", kind
);
172 get_vbytes_v1 (unsigned short kind
, ssize_t size
, size_t vlen
)
177 return (sizeof (ctf_array_v1_t
));
179 return (sizeof (unsigned short) * (vlen
+ (vlen
& 1)));
182 if (size
< CTF_LSTRUCT_THRESH_V1
)
183 return (sizeof (ctf_member_v1_t
) * vlen
);
185 return (sizeof (ctf_lmember_v1_t
) * vlen
);
188 return (get_vbytes_common (kind
, size
, vlen
));
192 get_vbytes_v2 (unsigned short kind
, ssize_t size
, size_t vlen
)
197 return (sizeof (ctf_array_t
));
199 return (sizeof (uint32_t) * (vlen
+ (vlen
& 1)));
202 if (size
< CTF_LSTRUCT_THRESH
)
203 return (sizeof (ctf_member_t
) * vlen
);
205 return (sizeof (ctf_lmember_t
) * vlen
);
208 return (get_vbytes_common (kind
, size
, vlen
));
211 static const ctf_fileops_t ctf_fileops
[] = {
212 {NULL
, NULL
, NULL
, NULL
, NULL
},
214 {get_kind_v1
, get_root_v1
, get_vlen_v1
, get_ctt_size_v1
, get_vbytes_v1
},
215 /* CTF_VERSION_1_UPGRADED_3 */
216 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
218 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
219 /* CTF_VERSION_3, identical to 2: only new type kinds */
220 {get_kind_v2
, get_root_v2
, get_vlen_v2
, get_ctt_size_v2
, get_vbytes_v2
},
223 /* Initialize the symtab translation table by filling each entry with the
224 offset of the CTF type or function data corresponding to each STT_FUNC or
225 STT_OBJECT entry in the symbol table. */
228 init_symtab (ctf_file_t
*fp
, const ctf_header_t
*hp
,
229 const ctf_sect_t
*sp
, const ctf_sect_t
*strp
)
231 const unsigned char *symp
= sp
->cts_data
;
232 uint32_t *xp
= fp
->ctf_sxlate
;
233 uint32_t *xend
= xp
+ fp
->ctf_nsyms
;
235 uint32_t objtoff
= hp
->cth_objtoff
;
236 uint32_t funcoff
= hp
->cth_funcoff
;
242 /* The CTF data object and function type sections are ordered to match
243 the relative order of the respective symbol types in the symtab.
244 If no type information is available for a symbol table entry, a
245 pad is inserted in the CTF section. As a further optimization,
246 anonymous or undefined symbols are omitted from the CTF data. */
248 for (; xp
< xend
; xp
++, symp
+= sp
->cts_entsize
)
250 if (sp
->cts_entsize
== sizeof (Elf32_Sym
))
251 gsp
= ctf_sym_to_elf64 ((Elf32_Sym
*) (uintptr_t) symp
, &sym
);
253 gsp
= (Elf64_Sym
*) (uintptr_t) symp
;
255 if (gsp
->st_name
< strp
->cts_size
)
256 name
= (const char *) strp
->cts_data
+ gsp
->st_name
;
260 if (gsp
->st_name
== 0 || gsp
->st_shndx
== SHN_UNDEF
261 || strcmp (name
, "_START_") == 0 || strcmp (name
, "_END_") == 0)
267 switch (ELF64_ST_TYPE (gsp
->st_info
))
270 if (objtoff
>= hp
->cth_funcoff
271 || (gsp
->st_shndx
== SHN_EXTABS
&& gsp
->st_value
== 0))
278 objtoff
+= sizeof (uint32_t);
282 if (funcoff
>= hp
->cth_typeoff
)
290 info
= *(uint32_t *) ((uintptr_t) fp
->ctf_buf
+ funcoff
);
291 vlen
= LCTF_INFO_VLEN (fp
, info
);
293 /* If we encounter a zero pad at the end, just skip it. Otherwise
294 skip over the function and its return type (+2) and the argument
297 if (LCTF_INFO_KIND (fp
, info
) == CTF_K_UNKNOWN
&& vlen
== 0)
298 funcoff
+= sizeof (uint32_t); /* Skip pad. */
300 funcoff
+= sizeof (uint32_t) * (vlen
+ 2);
309 ctf_dprintf ("loaded %lu symtab entries\n", fp
->ctf_nsyms
);
313 /* Set the CTF base pointer and derive the buf pointer from it, initializing
314 everything in the ctf_file that depends on the base or buf pointers. */
317 ctf_set_base (ctf_file_t
*fp
, const ctf_header_t
*hp
, void *base
)
320 fp
->ctf_buf
= fp
->ctf_base
+ sizeof (ctf_header_t
);
321 fp
->ctf_vars
= (ctf_varent_t
*) ((const char *) fp
->ctf_buf
+
323 fp
->ctf_nvars
= (hp
->cth_typeoff
- hp
->cth_varoff
) / sizeof (ctf_varent_t
);
325 fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
= (const char *) fp
->ctf_buf
327 fp
->ctf_str
[CTF_STRTAB_0
].cts_len
= hp
->cth_strlen
;
329 /* If we have a parent container name and label, store the relocated
330 string pointers in the CTF container for easy access later. */
332 /* Note: before conversion, these will be set to values that will be
333 immediately invalidated by the conversion process, but the conversion
334 process will call ctf_set_base() again to fix things up. */
336 if (hp
->cth_parlabel
!= 0)
337 fp
->ctf_parlabel
= ctf_strptr (fp
, hp
->cth_parlabel
);
338 if (hp
->cth_parname
!= 0)
339 fp
->ctf_parname
= ctf_strptr (fp
, hp
->cth_parname
);
341 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
342 fp
->ctf_parname
? fp
->ctf_parname
: "<NULL>",
343 fp
->ctf_parlabel
? fp
->ctf_parlabel
: "<NULL>");
346 /* Free a ctf_base pointer: the pointer passed, or (if NULL) fp->ctf_base. */
348 ctf_free_base (ctf_file_t
*fp
, unsigned char *ctf_base
)
355 base
= (unsigned char *) fp
->ctf_base
;
357 if (base
!= fp
->ctf_data
.cts_data
&& base
!= NULL
)
361 /* Set the version of the CTF file. */
363 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
364 the variable data list associated with each type has been upgraded: the
365 caller must ensure this has been done in advance. */
368 ctf_set_version (ctf_file_t
* fp
, ctf_header_t
* cth
, int ctf_version
)
370 fp
->ctf_version
= ctf_version
;
371 cth
->cth_version
= ctf_version
;
372 fp
->ctf_fileops
= &ctf_fileops
[ctf_version
];
375 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3).
377 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
378 not be called before reallocation is complete.
380 Type kinds not checked here due to nonexistence in older formats:
383 upgrade_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
385 const ctf_type_v1_t
*tbuf
;
386 const ctf_type_v1_t
*tend
;
387 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_base
;
390 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
391 const ctf_type_v1_t
*tp
;
393 ctf_header_t
*new_cth
;
395 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
396 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
398 /* Much like init_types(), this is a two-pass process.
400 First, figure out the new type-section size needed. (It is possible,
401 in theory, for it to be less than the old size, but this is very
402 unlikely. It cannot be so small that cth_typeoff ends up of negative
403 size. We validate this with an assertion below.)
405 We must cater not only for changes in vlen and types sizes but also
406 for changes in 'increment', which happen because v2 places some types
407 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
409 for (tp
= tbuf
; tp
< tend
;
410 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
412 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
413 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
415 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
416 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
418 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
420 v2bytes
= get_vbytes_v2 (kind
, size
, vlen
);
422 if ((vbytes
< 0) || (size
< 0))
425 increase
+= v2increment
- increment
; /* May be negative. */
426 increase
+= v2bytes
- vbytes
;
429 /* Allocate enough room for the new buffer, then copy everything but the
430 type section into place, and reset the base accordingly. Leave the
431 version number unchanged, so that LCTF_INFO_* still works on the
432 as-yet-untranslated type info. */
434 if ((ctf_base
= ctf_alloc (fp
->ctf_size
+ increase
)) == NULL
)
437 memcpy (ctf_base
, fp
->ctf_base
, sizeof (ctf_header_t
) + cth
->cth_typeoff
);
438 memcpy (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
+ increase
,
439 fp
->ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
,
442 memset (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_typeoff
, 0,
443 cth
->cth_stroff
- cth
->cth_typeoff
+ increase
);
445 /* The cth here is an automatic variable in ctf_bufopen(), and transient
446 (a copy maintained because at that stage the header read out of the
447 ctf file may be read-only). We make all modifications in the
448 canonical copy at ctf_base (by now, writable), then copy it back into
451 new_cth
= (ctf_header_t
*) ctf_base
;
452 new_cth
->cth_stroff
+= increase
;
453 fp
->ctf_size
+= increase
;
454 assert (new_cth
->cth_stroff
>= new_cth
->cth_typeoff
);
455 ctf_set_base (fp
, new_cth
, ctf_base
);
457 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ new_cth
->cth_typeoff
);
459 /* Iterate through all the types again, upgrading them.
461 Everything that hasn't changed can just be outright memcpy()ed.
462 Things that have changed need field-by-field consideration. */
464 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
465 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
466 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
468 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
469 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
470 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
472 void *vdata
, *v2data
;
474 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
475 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
477 t2p
->ctt_name
= tp
->ctt_name
;
478 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
489 t2p
->ctt_type
= tp
->ctt_type
;
498 if ((size_t) size
<= CTF_MAX_SIZE
)
499 t2p
->ctt_size
= size
;
502 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
503 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
508 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
509 v2bytes
= get_vbytes_v2 (kind
, v2size
, vlen
);
511 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
512 these are not identical (and having them different makes no
513 sense semantically). */
515 assert (size
== v2size
);
517 /* Now the varlen info. */
519 vdata
= (void *) ((uintptr_t) tp
+ increment
);
520 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
526 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
527 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
529 a2p
->cta_contents
= ap
->cta_contents
;
530 a2p
->cta_index
= ap
->cta_index
;
531 a2p
->cta_nelems
= ap
->cta_nelems
;
538 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
539 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
540 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
541 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
544 /* We walk all four pointers forward, but only reference the two
545 that are valid for the given size, to avoid quadruplicating all
548 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
551 if (size
< CTF_LSTRUCT_THRESH_V1
)
553 offset
= m1
->ctm_offset
;
554 tmp
.ctm_name
= m1
->ctm_name
;
555 tmp
.ctm_type
= m1
->ctm_type
;
559 offset
= CTF_LMEM_OFFSET (lm1
);
560 tmp
.ctm_name
= lm1
->ctlm_name
;
561 tmp
.ctm_type
= lm1
->ctlm_type
;
563 if (size
< CTF_LSTRUCT_THRESH
)
565 m2
->ctm_name
= tmp
.ctm_name
;
566 m2
->ctm_type
= tmp
.ctm_type
;
567 m2
->ctm_offset
= offset
;
571 lm2
->ctlm_name
= tmp
.ctm_name
;
572 lm2
->ctlm_type
= tmp
.ctm_type
;
573 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
574 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
582 unsigned short *a1
= (unsigned short *) vdata
;
583 uint32_t *a2
= (uint32_t *) v2data
;
585 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
590 /* Catch out-of-sync get_vbytes_*(). */
591 assert (vbytes
== v2bytes
);
592 memcpy (v2data
, vdata
, vbytes
);
596 /* Verify that the entire region was converted. If not, we are either
597 converting too much, or too little (leading to a buffer overrun either here
598 or at read time, in init_types().) */
600 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== new_cth
->cth_stroff
);
602 ctf_set_version (fp
, (ctf_header_t
*) ctf_base
, CTF_VERSION_1_UPGRADED_3
);
603 ctf_free_base (fp
, old_ctf_base
);
604 memcpy (cth
, new_cth
, sizeof (ctf_header_t
));
609 /* Initialize the type ID translation table with the byte offset of each type,
610 and initialize the hash tables of each named type. Upgrade the type table to
611 the latest supported representation in the process, if needed, and if this
612 recension of libctf supports upgrading. */
615 init_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
617 const ctf_type_t
*tbuf
;
618 const ctf_type_t
*tend
;
620 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
621 const ctf_type_t
*tp
;
626 /* We determine whether the container is a child or a parent based on
627 the value of cth_parname. */
629 int child
= cth
->cth_parname
!= 0;
630 int nlstructs
= 0, nlunions
= 0;
633 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
636 if ((err
= upgrade_types (fp
, cth
)) != 0)
637 return err
; /* Upgrade failed. */
640 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
641 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
643 /* We make two passes through the entire type section. In this first
644 pass, we count the number of each type and the total number of types. */
646 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
648 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
649 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
650 ssize_t size
, increment
, vbytes
;
652 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
653 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
658 if (kind
== CTF_K_FORWARD
)
660 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
661 so bump that population count too. If ctt_type is unknown, treat
662 the tag as a struct. */
664 if (tp
->ctt_type
== CTF_K_UNKNOWN
|| tp
->ctt_type
>= CTF_K_MAX
)
669 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
675 ctf_dprintf ("CTF container %p is a child\n", (void *) fp
);
676 fp
->ctf_flags
|= LCTF_CHILD
;
679 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp
);
681 /* Now that we've counted up the number of each type, we can allocate
682 the hash tables, type translation table, and pointer table. */
684 if ((fp
->ctf_structs
= ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
685 ctf_hash_eq_string
)) == NULL
)
688 if ((fp
->ctf_unions
= ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
689 ctf_hash_eq_string
)) == NULL
)
692 if ((fp
->ctf_enums
= ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
693 ctf_hash_eq_string
)) == NULL
)
696 if ((fp
->ctf_names
= ctf_hash_create (pop
[CTF_K_INTEGER
] +
698 pop
[CTF_K_FUNCTION
] +
701 pop
[CTF_K_VOLATILE
] +
705 ctf_hash_eq_string
)) == NULL
)
708 fp
->ctf_txlate
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
709 fp
->ctf_ptrtab
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
711 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
712 return ENOMEM
; /* Memory allocation failed. */
715 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
717 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
718 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
720 /* In the second pass through the types, we fill in each entry of the
721 type and pointer tables and add names to the appropriate hashes. */
723 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
725 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
726 unsigned short flag
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
727 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
728 ssize_t size
, increment
, vbytes
;
732 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
733 name
= ctf_strptr (fp
, tp
->ctt_name
);
734 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
740 /* Names are reused by bit-fields, which are differentiated by their
741 encodings, and so typically we'd record only the first instance of
742 a given intrinsic. However, we replace an existing type with a
743 root-visible version so that we can be sure to find it when
744 checking for conflicting definitions in ctf_add_type(). */
746 if (((ctf_hash_lookup_type (fp
->ctf_names
, fp
, name
)) == 0)
747 || (flag
& CTF_ADD_ROOT
))
749 err
= ctf_hash_define_type (fp
->ctf_names
, fp
,
750 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
752 if (err
!= 0 && err
!= ECTF_STRTAB
)
757 /* These kinds have no name, so do not need interning into any
764 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
765 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
767 if (err
!= 0 && err
!= ECTF_STRTAB
)
772 err
= ctf_hash_define_type (fp
->ctf_structs
, fp
,
773 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
776 if (err
!= 0 && err
!= ECTF_STRTAB
)
779 if (size
>= CTF_LSTRUCT_THRESH
)
784 err
= ctf_hash_define_type (fp
->ctf_unions
, fp
,
785 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
788 if (err
!= 0 && err
!= ECTF_STRTAB
)
791 if (size
>= CTF_LSTRUCT_THRESH
)
796 err
= ctf_hash_define_type (fp
->ctf_enums
, fp
,
797 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
800 if (err
!= 0 && err
!= ECTF_STRTAB
)
805 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
806 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
808 if (err
!= 0 && err
!= ECTF_STRTAB
)
813 /* Only insert forward tags into the given hash if the type or tag
814 name is not already present. */
815 switch (tp
->ctt_type
)
818 hp
= fp
->ctf_structs
;
827 hp
= fp
->ctf_structs
;
830 if (ctf_hash_lookup_type (hp
, fp
, name
) == 0)
832 err
= ctf_hash_insert_type (hp
, fp
,
833 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
835 if (err
!= 0 && err
!= ECTF_STRTAB
)
841 /* If the type referenced by the pointer is in this CTF container,
842 then store the index of the pointer type in
843 fp->ctf_ptrtab[ index of referenced type ]. */
845 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
846 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
847 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
853 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
854 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
856 if (err
!= 0 && err
!= ECTF_STRTAB
)
860 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
865 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
866 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
869 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
870 ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp
->ctf_enums
));
871 ctf_dprintf ("%u struct names hashed (%d long)\n",
872 ctf_hash_size (fp
->ctf_structs
), nlstructs
);
873 ctf_dprintf ("%u union names hashed (%d long)\n",
874 ctf_hash_size (fp
->ctf_unions
), nlunions
);
875 ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp
->ctf_names
));
877 /* Make an additional pass through the pointer table to find pointers that
878 point to anonymous typedef nodes. If we find one, modify the pointer table
879 so that the pointer is also known to point to the node that is referenced
880 by the anonymous typedef node. */
882 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
884 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
886 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
888 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
&&
889 strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0 &&
890 LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
&&
891 LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
892 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
899 /* Endianness-flipping routines.
901 We flip everything, mindlessly, even 1-byte entities, so that future
902 expansions do not require changes to this code. */
904 /* < C11? define away static assertions. */
906 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
907 #define _Static_assert(cond, err)
910 /* Swap the endianness of something. */
912 #define swap_thing(x) \
914 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
915 && sizeof (x) <= 8), \
916 "Invalid size, update endianness code"); \
917 switch (sizeof (x)) { \
918 case 2: x = bswap_16 (x); break; \
919 case 4: x = bswap_32 (x); break; \
920 case 8: x = bswap_64 (x); break; \
921 case 1: /* Nothing needs doing */ \
926 /* Flip the endianness of the CTF header. */
929 flip_header (ctf_header_t
*cth
)
931 swap_thing (cth
->cth_preamble
.ctp_magic
);
932 swap_thing (cth
->cth_preamble
.ctp_version
);
933 swap_thing (cth
->cth_preamble
.ctp_flags
);
934 swap_thing (cth
->cth_parlabel
);
935 swap_thing (cth
->cth_parname
);
936 swap_thing (cth
->cth_objtoff
);
937 swap_thing (cth
->cth_funcoff
);
938 swap_thing (cth
->cth_varoff
);
939 swap_thing (cth
->cth_typeoff
);
940 swap_thing (cth
->cth_stroff
);
941 swap_thing (cth
->cth_strlen
);
944 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
947 flip_lbls (void *start
, size_t len
)
949 ctf_lblent_t
*lbl
= start
;
951 for (ssize_t i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
953 swap_thing (lbl
->ctl_label
);
954 swap_thing (lbl
->ctl_type
);
958 /* Flip the endianness of the data-object or function sections, an array of
959 uint32_t. (The function section has more internal structure, but that
960 structure is an array of uint32_t, so can be treated as one big array for
964 flip_objts (void *start
, size_t len
)
966 uint32_t *obj
= start
;
968 for (ssize_t i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
972 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
975 flip_vars (void *start
, size_t len
)
977 ctf_varent_t
*var
= start
;
979 for (ssize_t i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
981 swap_thing (var
->ctv_name
);
982 swap_thing (var
->ctv_type
);
986 /* Flip the endianness of the type section, a tagged array of ctf_type or
987 ctf_stype followed by variable data. */
990 flip_types (void *start
, size_t len
)
992 ctf_type_t
*t
= start
;
994 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
996 swap_thing (t
->ctt_name
);
997 swap_thing (t
->ctt_info
);
998 swap_thing (t
->ctt_size
);
1000 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1001 size_t size
= t
->ctt_size
;
1002 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1003 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1005 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1007 swap_thing (t
->ctt_lsizehi
);
1008 swap_thing (t
->ctt_lsizelo
);
1009 size
= CTF_TYPE_LSIZE (t
);
1010 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1013 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1021 case CTF_K_VOLATILE
:
1023 case CTF_K_RESTRICT
:
1024 /* These types have no vlen data to swap. */
1025 assert (vbytes
== 0);
1031 /* These types have a single uint32_t. */
1033 uint32_t *item
= (uint32_t *) t
;
1039 case CTF_K_FUNCTION
:
1041 /* This type has a bunch of uint32_ts. */
1043 uint32_t *item
= (uint32_t *) t
;
1045 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1052 /* This has a single ctf_array_t. */
1054 ctf_array_t
*a
= (ctf_array_t
*) t
;
1056 assert (vbytes
== sizeof (ctf_array_t
));
1057 swap_thing (a
->cta_contents
);
1058 swap_thing (a
->cta_index
);
1059 swap_thing (a
->cta_nelems
);
1066 /* This has a single ctf_slice_t. */
1068 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1070 assert (vbytes
== sizeof (ctf_slice_t
));
1071 swap_thing (s
->cts_type
);
1072 swap_thing (s
->cts_offset
);
1073 swap_thing (s
->cts_bits
);
1081 /* This has an array of ctf_member or ctf_lmember, depending on
1082 size. We could consider it to be a simple array of uint32_t,
1083 but for safety's sake in case these structures ever acquire
1084 non-uint32_t members, do it member by member. */
1086 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1088 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1089 for (ssize_t i
= vlen
; i
> 0; i
--, lm
++)
1091 swap_thing (lm
->ctlm_name
);
1092 swap_thing (lm
->ctlm_offsethi
);
1093 swap_thing (lm
->ctlm_type
);
1094 swap_thing (lm
->ctlm_offsetlo
);
1099 ctf_member_t
*m
= (ctf_member_t
*) t
;
1100 for (ssize_t i
= vlen
; i
> 0; i
--, m
++)
1102 swap_thing (m
->ctm_name
);
1103 swap_thing (m
->ctm_offset
);
1104 swap_thing (m
->ctm_type
);
1112 /* This has an array of ctf_enum_t. */
1114 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1116 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1118 swap_thing (item
->cte_name
);
1119 swap_thing (item
->cte_value
);
1124 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1126 return ECTF_CORRUPT
;
1129 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1135 /* Flip the endianness of BASE, given the offsets in the (already endian-
1138 All of this stuff happens before the header is fully initialized, so the
1139 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1140 data, this is no real loss. */
1143 flip_ctf (ctf_header_t
*cth
, unsigned char *base
)
1145 base
+= sizeof (ctf_header_t
);
1147 flip_lbls (base
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1148 flip_objts (base
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1149 flip_objts (base
+ cth
->cth_funcoff
, cth
->cth_varoff
- cth
->cth_funcoff
);
1150 flip_vars (base
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1151 return flip_types (base
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1154 /* Open a CTF file, mocking up a suitable ctf_sect. */
1155 ctf_file_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1156 const char *symsect
, size_t symsect_size
,
1157 size_t symsect_entsize
,
1158 const char *strsect
, size_t strsect_size
,
1161 ctf_sect_t skeleton
;
1163 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1164 ctf_sect_t
*ctfsectp
= NULL
;
1165 ctf_sect_t
*symsectp
= NULL
;
1166 ctf_sect_t
*strsectp
= NULL
;
1168 skeleton
.cts_name
= _CTF_SECTION
;
1169 skeleton
.cts_entsize
= 1;
1173 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1174 ctf_sect
.cts_data
= ctfsect
;
1175 ctf_sect
.cts_size
= ctfsect_size
;
1176 ctfsectp
= &ctf_sect
;
1181 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1182 sym_sect
.cts_data
= symsect
;
1183 sym_sect
.cts_size
= symsect_size
;
1184 sym_sect
.cts_entsize
= symsect_entsize
;
1185 symsectp
= &sym_sect
;
1190 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1191 str_sect
.cts_data
= strsect
;
1192 str_sect
.cts_size
= strsect_size
;
1193 strsectp
= &str_sect
;
1196 return ctf_bufopen (ctfsectp
, symsectp
, strsectp
, errp
);
1199 /* Decode the specified CTF buffer and optional symbol table, and create a new
1200 CTF container representing the symbolic debugging information. This code can
1201 be used directly by the debugger, or it can be used as the engine for
1202 ctf_fdopen() or ctf_open(), below. */
1205 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1206 const ctf_sect_t
*strsect
, int *errp
)
1208 const ctf_preamble_t
*pp
;
1213 int foreign_endian
= 0;
1216 libctf_init_debug();
1218 if (ctfsect
== NULL
|| ((symsect
== NULL
) != (strsect
== NULL
)))
1219 return (ctf_set_open_errno (errp
, EINVAL
));
1221 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1222 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1223 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1225 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1226 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1228 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1229 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1231 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1232 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1234 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1236 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1237 pp
->ctp_magic
, pp
->ctp_version
);
1239 /* Validate each part of the CTF header.
1241 First, we validate the preamble (common to all versions). At that point,
1242 we know the endianness and specific header version, and can validate the
1243 version-specific parts including section offsets and alignments.
1245 We specifically do not support foreign-endian old versions. */
1247 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1249 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1251 if (pp
->ctp_version
!= CTF_VERSION_3
)
1252 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1256 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1259 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1260 || (pp
->ctp_version
> CTF_VERSION_3
)))
1261 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1263 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1265 /* The symtab can contain function entries which contain embedded ctf
1266 info. We do not support dynamically upgrading such entries (none
1267 should exist in any case, since dwarf2ctf does not create them). */
1269 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1270 "supported\n", pp
->ctp_version
);
1271 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1274 if (ctfsect
->cts_size
< sizeof (ctf_header_t
))
1275 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1277 memcpy (&hp
, ctfsect
->cts_data
, sizeof (hp
));
1282 ctf_dprintf ("header offsets: %x/%x/%x/%x/%x/%x/%x\n",
1283 hp
.cth_lbloff
, hp
.cth_objtoff
, hp
.cth_funcoff
, hp
.cth_varoff
,
1284 hp
.cth_typeoff
, hp
.cth_stroff
, hp
.cth_strlen
);
1285 hdrsz
= sizeof (ctf_header_t
);
1287 size
= hp
.cth_stroff
+ hp
.cth_strlen
;
1289 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size
);
1291 if (hp
.cth_lbloff
> size
|| hp
.cth_objtoff
> size
1292 || hp
.cth_funcoff
> size
|| hp
.cth_typeoff
> size
|| hp
.cth_stroff
> size
)
1293 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1295 if (hp
.cth_lbloff
> hp
.cth_objtoff
1296 || hp
.cth_objtoff
> hp
.cth_funcoff
1297 || hp
.cth_funcoff
> hp
.cth_typeoff
1298 || hp
.cth_funcoff
> hp
.cth_varoff
1299 || hp
.cth_varoff
> hp
.cth_typeoff
|| hp
.cth_typeoff
> hp
.cth_stroff
)
1300 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1302 if ((hp
.cth_lbloff
& 3) || (hp
.cth_objtoff
& 1)
1303 || (hp
.cth_funcoff
& 1) || (hp
.cth_varoff
& 3) || (hp
.cth_typeoff
& 3))
1304 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1306 /* Once everything is determined to be valid, attempt to decompress the CTF
1307 data buffer if it is compressed, or copy it into new storage if it is not
1308 compressed but needs endian-flipping. Otherwise we just put the data
1309 section's buffer pointer into ctf_buf, below. */
1311 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1314 if (hp
.cth_flags
& CTF_F_COMPRESS
)
1321 if ((base
= ctf_alloc (size
+ hdrsz
)) == NULL
)
1322 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1324 memcpy (base
, ctfsect
->cts_data
, hdrsz
);
1325 ((ctf_preamble_t
*) base
)->ctp_flags
&= ~CTF_F_COMPRESS
;
1326 buf
= (unsigned char *) base
+ hdrsz
;
1328 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1329 srclen
= ctfsect
->cts_size
- hdrsz
;
1332 if ((rc
= uncompress (buf
, &dstlen
, src
, srclen
)) != Z_OK
)
1334 ctf_dprintf ("zlib inflate err: %s\n", zError (rc
));
1336 return (ctf_set_open_errno (errp
, ECTF_DECOMPRESS
));
1339 if ((size_t) dstlen
!= size
)
1341 ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1342 "bytes\n", (unsigned long) dstlen
, (unsigned long) size
);
1344 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1348 else if (foreign_endian
)
1350 if ((base
= ctf_alloc (size
+ hdrsz
)) == NULL
)
1351 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1355 base
= (void *) ctfsect
->cts_data
;
1356 buf
= (unsigned char *) base
+ hdrsz
;
1359 /* Once we have uncompressed and validated the CTF data buffer, we can
1360 proceed with allocating a ctf_file_t and initializing it.
1362 Nothing that depends on buf or base should be set directly in this function
1363 before the init_types() call, because it may be reallocated during
1364 transparent upgrade if this recension of libctf is so configured: see
1365 ctf_set_base() and ctf_realloc_base(). */
1367 if ((fp
= ctf_alloc (sizeof (ctf_file_t
))) == NULL
)
1368 return (ctf_set_open_errno (errp
, ENOMEM
));
1370 memset (fp
, 0, sizeof (ctf_file_t
));
1371 ctf_set_version (fp
, &hp
, hp
.cth_version
);
1373 if (_libctf_unlikely_ (hp
.cth_version
< CTF_VERSION_2
))
1374 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
1376 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1378 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1380 if (symsect
!= NULL
)
1382 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1383 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1386 if (fp
->ctf_data
.cts_name
!= NULL
)
1387 fp
->ctf_data
.cts_name
= ctf_strdup (fp
->ctf_data
.cts_name
);
1388 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1389 fp
->ctf_symtab
.cts_name
= ctf_strdup (fp
->ctf_symtab
.cts_name
);
1390 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1391 fp
->ctf_strtab
.cts_name
= ctf_strdup (fp
->ctf_strtab
.cts_name
);
1393 if (fp
->ctf_data
.cts_name
== NULL
)
1394 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1395 if (fp
->ctf_symtab
.cts_name
== NULL
)
1396 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1397 if (fp
->ctf_strtab
.cts_name
== NULL
)
1398 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1400 if (strsect
!= NULL
)
1402 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1403 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1406 if (foreign_endian
&&
1407 (err
= flip_ctf (&hp
, base
)) != 0)
1409 /* We can be certain that flip_ctf() will have endian-flipped everything
1410 other than the types table when we return. In particular the header
1411 is fine, so set it, to allow freeing to use the usual code path. */
1413 (void) ctf_set_open_errno (errp
, err
);
1414 ctf_set_base (fp
, &hp
, base
);
1418 ctf_set_base (fp
, &hp
, base
);
1419 fp
->ctf_size
= size
+ hdrsz
;
1421 if ((err
= init_types (fp
, &hp
)) != 0)
1423 (void) ctf_set_open_errno (errp
, err
);
1427 /* If we have a symbol table section, allocate and initialize
1428 the symtab translation table, pointed to by ctf_sxlate. */
1430 if (symsect
!= NULL
)
1432 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1433 fp
->ctf_sxlate
= ctf_alloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1435 if (fp
->ctf_sxlate
== NULL
)
1437 (void) ctf_set_open_errno (errp
, ENOMEM
);
1441 if ((err
= init_symtab (fp
, &hp
, symsect
, strsect
)) != 0)
1443 (void) ctf_set_open_errno (errp
, err
);
1448 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1449 array of type name prefixes and the corresponding ctf_hash to use.
1450 NOTE: This code must be kept in sync with the code in ctf_update(). */
1451 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1452 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1453 fp
->ctf_lookups
[0].ctl_hash
= fp
->ctf_structs
;
1454 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1455 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1456 fp
->ctf_lookups
[1].ctl_hash
= fp
->ctf_unions
;
1457 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1458 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1459 fp
->ctf_lookups
[2].ctl_hash
= fp
->ctf_enums
;
1460 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1461 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1462 fp
->ctf_lookups
[3].ctl_hash
= fp
->ctf_names
;
1463 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1464 fp
->ctf_lookups
[4].ctl_len
= 0;
1465 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1467 if (symsect
!= NULL
)
1469 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1470 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1472 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1475 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1481 ctf_file_close (fp
);
1485 /* Close the specified CTF container and free associated data structures. Note
1486 that ctf_file_close() is a reference counted operation: if the specified file
1487 is the parent of other active containers, its reference count will be greater
1488 than one and it will be freed later when no active children exist. */
1491 ctf_file_close (ctf_file_t
*fp
)
1493 ctf_dtdef_t
*dtd
, *ntd
;
1494 ctf_dvdef_t
*dvd
, *nvd
;
1497 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1499 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1501 if (fp
->ctf_refcnt
> 1)
1507 if (fp
->ctf_dynparname
!= NULL
)
1508 ctf_free (fp
->ctf_dynparname
);
1510 if (fp
->ctf_parent
!= NULL
)
1511 ctf_file_close (fp
->ctf_parent
);
1513 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1515 ntd
= ctf_list_next (dtd
);
1516 ctf_dtd_delete (fp
, dtd
);
1518 ctf_dynhash_destroy (fp
->ctf_dthash
);
1519 ctf_dynhash_destroy (fp
->ctf_dtbyname
);
1521 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1523 nvd
= ctf_list_next (dvd
);
1524 ctf_dvd_delete (fp
, dvd
);
1526 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1528 ctf_free (fp
->ctf_tmp_typeslice
);
1530 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
&&
1531 fp
->ctf_data
.cts_name
!= NULL
)
1532 ctf_free ((char *) fp
->ctf_data
.cts_name
);
1534 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
&&
1535 fp
->ctf_symtab
.cts_name
!= NULL
)
1536 ctf_free ((char *) fp
->ctf_symtab
.cts_name
);
1538 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
&&
1539 fp
->ctf_strtab
.cts_name
!= NULL
)
1540 ctf_free ((char *) fp
->ctf_strtab
.cts_name
);
1542 else if (fp
->ctf_data_mmapped
)
1543 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1545 ctf_free_base (fp
, NULL
);
1547 if (fp
->ctf_sxlate
!= NULL
)
1548 ctf_free (fp
->ctf_sxlate
);
1550 if (fp
->ctf_txlate
!= NULL
)
1551 ctf_free (fp
->ctf_txlate
);
1553 if (fp
->ctf_ptrtab
!= NULL
)
1554 ctf_free (fp
->ctf_ptrtab
);
1556 ctf_hash_destroy (fp
->ctf_structs
);
1557 ctf_hash_destroy (fp
->ctf_unions
);
1558 ctf_hash_destroy (fp
->ctf_enums
);
1559 ctf_hash_destroy (fp
->ctf_names
);
1564 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1565 archive, so closing one is just like closing an archive. */
1567 ctf_close (ctf_archive_t
*arc
)
1569 ctf_arc_close (arc
);
1572 /* Get the CTF archive from which this ctf_file_t is derived. */
1574 ctf_get_arc (const ctf_file_t
*fp
)
1576 return fp
->ctf_archive
;
1579 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1580 ctfsect's data * after ctf_file_close(), which is why we return the actual
1581 structure, not a pointer to it, since that is likely to become a pointer to
1582 freed data before the return value is used under the expected use case of
1583 ctf_getsect()/ ctf_file_close()/free(). */
1585 ctf_getdatasect (const ctf_file_t
*fp
)
1587 return fp
->ctf_data
;
1590 /* Return the CTF handle for the parent CTF container, if one exists.
1591 Otherwise return NULL to indicate this container has no imported parent. */
1593 ctf_parent_file (ctf_file_t
*fp
)
1595 return fp
->ctf_parent
;
1598 /* Return the name of the parent CTF container, if one exists. Otherwise
1599 return NULL to indicate this container is a root container. */
1601 ctf_parent_name (ctf_file_t
*fp
)
1603 return fp
->ctf_parname
;
1606 /* Set the parent name. It is an error to call this routine without calling
1607 ctf_import() at some point. */
1609 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1611 if (fp
->ctf_dynparname
!= NULL
)
1612 ctf_free (fp
->ctf_dynparname
);
1614 fp
->ctf_dynparname
= ctf_strdup (name
);
1615 fp
->ctf_parname
= fp
->ctf_dynparname
;
1618 /* Import the types from the specified parent container by storing a pointer
1619 to it in ctf_parent and incrementing its reference count. Only one parent
1620 is allowed: if a parent already exists, it is replaced by the new parent. */
1622 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1624 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1625 return (ctf_set_errno (fp
, EINVAL
));
1627 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1628 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1630 if (fp
->ctf_parent
!= NULL
)
1631 ctf_file_close (fp
->ctf_parent
);
1635 fp
->ctf_flags
|= LCTF_CHILD
;
1638 if (fp
->ctf_parname
== NULL
)
1639 ctf_parent_name_set (fp
, "PARENT");
1641 fp
->ctf_parent
= pfp
;
1645 /* Set the data model constant for the CTF container. */
1647 ctf_setmodel (ctf_file_t
*fp
, int model
)
1649 const ctf_dmodel_t
*dp
;
1651 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1653 if (dp
->ctd_code
== model
)
1655 fp
->ctf_dmodel
= dp
;
1660 return (ctf_set_errno (fp
, EINVAL
));
1663 /* Return the data model constant for the CTF container. */
1665 ctf_getmodel (ctf_file_t
*fp
)
1667 return fp
->ctf_dmodel
->ctd_code
;
1670 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1673 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1675 fp
->ctf_specific
= data
;
1678 /* Retrieve the arbitrary pointer again. */
1680 ctf_getspecific (ctf_file_t
*fp
)
1682 return fp
->ctf_specific
;