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
)
861 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
862 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
865 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
866 ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp
->ctf_enums
));
867 ctf_dprintf ("%u struct names hashed (%d long)\n",
868 ctf_hash_size (fp
->ctf_structs
), nlstructs
);
869 ctf_dprintf ("%u union names hashed (%d long)\n",
870 ctf_hash_size (fp
->ctf_unions
), nlunions
);
871 ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp
->ctf_names
));
873 /* Make an additional pass through the pointer table to find pointers that
874 point to anonymous typedef nodes. If we find one, modify the pointer table
875 so that the pointer is also known to point to the node that is referenced
876 by the anonymous typedef node. */
878 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
880 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
882 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
884 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
&&
885 strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0 &&
886 LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
&&
887 LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
888 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
895 /* Endianness-flipping routines.
897 We flip everything, mindlessly, even 1-byte entities, so that future
898 expansions do not require changes to this code. */
900 /* < C11? define away static assertions. */
902 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
903 #define _Static_assert(cond, err)
906 /* Swap the endianness of something. */
908 #define swap_thing(x) \
910 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
911 && sizeof (x) <= 8), \
912 "Invalid size, update endianness code"); \
913 switch (sizeof (x)) { \
914 case 2: x = bswap_16 (x); break; \
915 case 4: x = bswap_32 (x); break; \
916 case 8: x = bswap_64 (x); break; \
917 case 1: /* Nothing needs doing */ \
922 /* Flip the endianness of the CTF header. */
925 flip_header (ctf_header_t
*cth
)
927 swap_thing (cth
->cth_preamble
.ctp_magic
);
928 swap_thing (cth
->cth_preamble
.ctp_version
);
929 swap_thing (cth
->cth_preamble
.ctp_flags
);
930 swap_thing (cth
->cth_parlabel
);
931 swap_thing (cth
->cth_parname
);
932 swap_thing (cth
->cth_objtoff
);
933 swap_thing (cth
->cth_funcoff
);
934 swap_thing (cth
->cth_varoff
);
935 swap_thing (cth
->cth_typeoff
);
936 swap_thing (cth
->cth_stroff
);
937 swap_thing (cth
->cth_strlen
);
940 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
943 flip_lbls (void *start
, size_t len
)
945 ctf_lblent_t
*lbl
= start
;
947 for (ssize_t i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
949 swap_thing (lbl
->ctl_label
);
950 swap_thing (lbl
->ctl_type
);
954 /* Flip the endianness of the data-object or function sections, an array of
955 uint32_t. (The function section has more internal structure, but that
956 structure is an array of uint32_t, so can be treated as one big array for
960 flip_objts (void *start
, size_t len
)
962 uint32_t *obj
= start
;
964 for (ssize_t i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
968 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
971 flip_vars (void *start
, size_t len
)
973 ctf_varent_t
*var
= start
;
975 for (ssize_t i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
977 swap_thing (var
->ctv_name
);
978 swap_thing (var
->ctv_type
);
982 /* Flip the endianness of the type section, a tagged array of ctf_type or
983 ctf_stype followed by variable data. */
986 flip_types (void *start
, size_t len
)
988 ctf_type_t
*t
= start
;
990 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
992 swap_thing (t
->ctt_name
);
993 swap_thing (t
->ctt_info
);
994 swap_thing (t
->ctt_size
);
996 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
997 size_t size
= t
->ctt_size
;
998 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
999 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1001 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1003 swap_thing (t
->ctt_lsizehi
);
1004 swap_thing (t
->ctt_lsizelo
);
1005 size
= CTF_TYPE_LSIZE (t
);
1006 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1009 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1017 case CTF_K_VOLATILE
:
1019 case CTF_K_RESTRICT
:
1020 /* These types have no vlen data to swap. */
1021 assert (vbytes
== 0);
1027 /* These types have a single uint32_t. */
1029 uint32_t *item
= (uint32_t *) t
;
1035 case CTF_K_FUNCTION
:
1037 /* This type has a bunch of uint32_ts. */
1039 uint32_t *item
= (uint32_t *) t
;
1041 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1048 /* This has a single ctf_array_t. */
1050 ctf_array_t
*a
= (ctf_array_t
*) t
;
1052 assert (vbytes
== sizeof (ctf_array_t
));
1053 swap_thing (a
->cta_contents
);
1054 swap_thing (a
->cta_index
);
1055 swap_thing (a
->cta_nelems
);
1062 /* This has a single ctf_slice_t. */
1064 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1066 assert (vbytes
== sizeof (ctf_slice_t
));
1067 swap_thing (s
->cts_type
);
1068 swap_thing (s
->cts_offset
);
1069 swap_thing (s
->cts_bits
);
1077 /* This has an array of ctf_member or ctf_lmember, depending on
1078 size. We could consider it to be a simple array of uint32_t,
1079 but for safety's sake in case these structures ever acquire
1080 non-uint32_t members, do it member by member. */
1082 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1084 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1085 for (ssize_t i
= vlen
; i
> 0; i
--, lm
++)
1087 swap_thing (lm
->ctlm_name
);
1088 swap_thing (lm
->ctlm_offsethi
);
1089 swap_thing (lm
->ctlm_type
);
1090 swap_thing (lm
->ctlm_offsetlo
);
1095 ctf_member_t
*m
= (ctf_member_t
*) t
;
1096 for (ssize_t i
= vlen
; i
> 0; i
--, m
++)
1098 swap_thing (m
->ctm_name
);
1099 swap_thing (m
->ctm_offset
);
1100 swap_thing (m
->ctm_type
);
1108 /* This has an array of ctf_enum_t. */
1110 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1112 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1114 swap_thing (item
->cte_name
);
1115 swap_thing (item
->cte_value
);
1120 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1122 return ECTF_CORRUPT
;
1125 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1131 /* Flip the endianness of BASE, given the offsets in the (already endian-
1134 All of this stuff happens before the header is fully initialized, so the
1135 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1136 data, this is no real loss. */
1139 flip_ctf (ctf_header_t
*cth
, unsigned char *base
)
1141 base
+= sizeof (ctf_header_t
);
1143 flip_lbls (base
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1144 flip_objts (base
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1145 flip_objts (base
+ cth
->cth_funcoff
, cth
->cth_varoff
- cth
->cth_funcoff
);
1146 flip_vars (base
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1147 return flip_types (base
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1150 /* Open a CTF file, mocking up a suitable ctf_sect. */
1151 ctf_file_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1152 const char *symsect
, size_t symsect_size
,
1153 size_t symsect_entsize
,
1154 const char *strsect
, size_t strsect_size
,
1157 ctf_sect_t skeleton
;
1159 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1160 ctf_sect_t
*ctfsectp
= NULL
;
1161 ctf_sect_t
*symsectp
= NULL
;
1162 ctf_sect_t
*strsectp
= NULL
;
1164 skeleton
.cts_name
= _CTF_SECTION
;
1165 skeleton
.cts_entsize
= 1;
1169 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1170 ctf_sect
.cts_data
= ctfsect
;
1171 ctf_sect
.cts_size
= ctfsect_size
;
1172 ctfsectp
= &ctf_sect
;
1177 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1178 sym_sect
.cts_data
= symsect
;
1179 sym_sect
.cts_size
= symsect_size
;
1180 sym_sect
.cts_entsize
= symsect_entsize
;
1181 symsectp
= &sym_sect
;
1186 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1187 str_sect
.cts_data
= strsect
;
1188 str_sect
.cts_size
= strsect_size
;
1189 strsectp
= &str_sect
;
1192 return ctf_bufopen (ctfsectp
, symsectp
, strsectp
, errp
);
1195 /* Decode the specified CTF buffer and optional symbol table, and create a new
1196 CTF container representing the symbolic debugging information. This code can
1197 be used directly by the debugger, or it can be used as the engine for
1198 ctf_fdopen() or ctf_open(), below. */
1201 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1202 const ctf_sect_t
*strsect
, int *errp
)
1204 const ctf_preamble_t
*pp
;
1209 int foreign_endian
= 0;
1212 libctf_init_debug();
1214 if (ctfsect
== NULL
|| ((symsect
== NULL
) != (strsect
== NULL
)))
1215 return (ctf_set_open_errno (errp
, EINVAL
));
1217 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1218 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1219 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1221 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1222 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1224 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1225 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1227 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1228 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1230 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1232 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1233 pp
->ctp_magic
, pp
->ctp_version
);
1235 /* Validate each part of the CTF header.
1237 First, we validate the preamble (common to all versions). At that point,
1238 we know the endianness and specific header version, and can validate the
1239 version-specific parts including section offsets and alignments.
1241 We specifically do not support foreign-endian old versions. */
1243 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1245 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1247 if (pp
->ctp_version
!= CTF_VERSION_3
)
1248 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1252 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1255 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1256 || (pp
->ctp_version
> CTF_VERSION_3
)))
1257 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1259 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1261 /* The symtab can contain function entries which contain embedded ctf
1262 info. We do not support dynamically upgrading such entries (none
1263 should exist in any case, since dwarf2ctf does not create them). */
1265 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1266 "supported\n", pp
->ctp_version
);
1267 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1270 if (ctfsect
->cts_size
< sizeof (ctf_header_t
))
1271 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1273 memcpy (&hp
, ctfsect
->cts_data
, sizeof (hp
));
1278 hdrsz
= sizeof (ctf_header_t
);
1280 size
= hp
.cth_stroff
+ hp
.cth_strlen
;
1282 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size
);
1284 if (hp
.cth_lbloff
> size
|| hp
.cth_objtoff
> size
1285 || hp
.cth_funcoff
> size
|| hp
.cth_typeoff
> size
|| hp
.cth_stroff
> size
)
1286 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1288 if (hp
.cth_lbloff
> hp
.cth_objtoff
1289 || hp
.cth_objtoff
> hp
.cth_funcoff
1290 || hp
.cth_funcoff
> hp
.cth_typeoff
1291 || hp
.cth_funcoff
> hp
.cth_varoff
1292 || hp
.cth_varoff
> hp
.cth_typeoff
|| hp
.cth_typeoff
> hp
.cth_stroff
)
1293 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1295 if ((hp
.cth_lbloff
& 3) || (hp
.cth_objtoff
& 1)
1296 || (hp
.cth_funcoff
& 1) || (hp
.cth_varoff
& 3) || (hp
.cth_typeoff
& 3))
1297 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1299 /* Once everything is determined to be valid, attempt to decompress the CTF
1300 data buffer if it is compressed, or copy it into new storage if it is not
1301 compressed but needs endian-flipping. Otherwise we just put the data
1302 section's buffer pointer into ctf_buf, below. */
1304 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1307 if (hp
.cth_flags
& CTF_F_COMPRESS
)
1314 if ((base
= ctf_alloc (size
+ hdrsz
)) == NULL
)
1315 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1317 memcpy (base
, ctfsect
->cts_data
, hdrsz
);
1318 ((ctf_preamble_t
*) base
)->ctp_flags
&= ~CTF_F_COMPRESS
;
1319 buf
= (unsigned char *) base
+ hdrsz
;
1321 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1322 srclen
= ctfsect
->cts_size
- hdrsz
;
1325 if ((rc
= uncompress (buf
, &dstlen
, src
, srclen
)) != Z_OK
)
1327 ctf_dprintf ("zlib inflate err: %s\n", zError (rc
));
1329 return (ctf_set_open_errno (errp
, ECTF_DECOMPRESS
));
1332 if ((size_t) dstlen
!= size
)
1334 ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1335 "bytes\n", (unsigned long) dstlen
, (unsigned long) size
);
1337 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1341 else if (foreign_endian
)
1343 if ((base
= ctf_alloc (size
+ hdrsz
)) == NULL
)
1344 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1348 base
= (void *) ctfsect
->cts_data
;
1349 buf
= (unsigned char *) base
+ hdrsz
;
1352 /* Once we have uncompressed and validated the CTF data buffer, we can
1353 proceed with allocating a ctf_file_t and initializing it.
1355 Nothing that depends on buf or base should be set directly in this function
1356 before the init_types() call, because it may be reallocated during
1357 transparent upgrade if this recension of libctf is so configured: see
1358 ctf_set_base() and ctf_realloc_base(). */
1360 if ((fp
= ctf_alloc (sizeof (ctf_file_t
))) == NULL
)
1361 return (ctf_set_open_errno (errp
, ENOMEM
));
1363 memset (fp
, 0, sizeof (ctf_file_t
));
1364 ctf_set_version (fp
, &hp
, hp
.cth_version
);
1366 if (_libctf_unlikely_ (hp
.cth_version
< CTF_VERSION_2
))
1367 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
1369 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1371 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1373 if (symsect
!= NULL
)
1375 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1376 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1379 if (fp
->ctf_data
.cts_name
!= NULL
)
1380 fp
->ctf_data
.cts_name
= ctf_strdup (fp
->ctf_data
.cts_name
);
1381 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1382 fp
->ctf_symtab
.cts_name
= ctf_strdup (fp
->ctf_symtab
.cts_name
);
1383 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1384 fp
->ctf_strtab
.cts_name
= ctf_strdup (fp
->ctf_strtab
.cts_name
);
1386 if (fp
->ctf_data
.cts_name
== NULL
)
1387 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1388 if (fp
->ctf_symtab
.cts_name
== NULL
)
1389 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1390 if (fp
->ctf_strtab
.cts_name
== NULL
)
1391 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1393 if (strsect
!= NULL
)
1395 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1396 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1399 if (foreign_endian
&&
1400 (err
= flip_ctf (&hp
, base
)) != 0)
1402 /* We can be certain that flip_ctf() will have endian-flipped everything
1403 other than the types table when we return. In particular the header
1404 is fine, so set it, to allow freeing to use the usual code path. */
1406 (void) ctf_set_open_errno (errp
, err
);
1407 ctf_set_base (fp
, &hp
, base
);
1411 ctf_set_base (fp
, &hp
, base
);
1412 fp
->ctf_size
= size
+ hdrsz
;
1414 if ((err
= init_types (fp
, &hp
)) != 0)
1416 (void) ctf_set_open_errno (errp
, err
);
1420 /* If we have a symbol table section, allocate and initialize
1421 the symtab translation table, pointed to by ctf_sxlate. */
1423 if (symsect
!= NULL
)
1425 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1426 fp
->ctf_sxlate
= ctf_alloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1428 if (fp
->ctf_sxlate
== NULL
)
1430 (void) ctf_set_open_errno (errp
, ENOMEM
);
1434 if ((err
= init_symtab (fp
, &hp
, symsect
, strsect
)) != 0)
1436 (void) ctf_set_open_errno (errp
, err
);
1441 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1442 array of type name prefixes and the corresponding ctf_hash to use.
1443 NOTE: This code must be kept in sync with the code in ctf_update(). */
1444 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1445 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1446 fp
->ctf_lookups
[0].ctl_hash
= fp
->ctf_structs
;
1447 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1448 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1449 fp
->ctf_lookups
[1].ctl_hash
= fp
->ctf_unions
;
1450 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1451 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1452 fp
->ctf_lookups
[2].ctl_hash
= fp
->ctf_enums
;
1453 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1454 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1455 fp
->ctf_lookups
[3].ctl_hash
= fp
->ctf_names
;
1456 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1457 fp
->ctf_lookups
[4].ctl_len
= 0;
1458 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1460 if (symsect
!= NULL
)
1462 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1463 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1465 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1468 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1474 ctf_file_close (fp
);
1478 /* Close the specified CTF container and free associated data structures. Note
1479 that ctf_file_close() is a reference counted operation: if the specified file
1480 is the parent of other active containers, its reference count will be greater
1481 than one and it will be freed later when no active children exist. */
1484 ctf_file_close (ctf_file_t
*fp
)
1486 ctf_dtdef_t
*dtd
, *ntd
;
1487 ctf_dvdef_t
*dvd
, *nvd
;
1490 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1492 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1494 if (fp
->ctf_refcnt
> 1)
1500 if (fp
->ctf_dynparname
!= NULL
)
1501 ctf_free (fp
->ctf_dynparname
);
1503 if (fp
->ctf_parent
!= NULL
)
1504 ctf_file_close (fp
->ctf_parent
);
1506 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1508 ntd
= ctf_list_next (dtd
);
1509 ctf_dtd_delete (fp
, dtd
);
1511 ctf_dynhash_destroy (fp
->ctf_dthash
);
1512 ctf_dynhash_destroy (fp
->ctf_dtbyname
);
1514 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1516 nvd
= ctf_list_next (dvd
);
1517 ctf_dvd_delete (fp
, dvd
);
1519 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1521 ctf_free (fp
->ctf_tmp_typeslice
);
1523 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
&&
1524 fp
->ctf_data
.cts_name
!= NULL
)
1525 ctf_free ((char *) fp
->ctf_data
.cts_name
);
1527 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
&&
1528 fp
->ctf_symtab
.cts_name
!= NULL
)
1529 ctf_free ((char *) fp
->ctf_symtab
.cts_name
);
1531 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
&&
1532 fp
->ctf_strtab
.cts_name
!= NULL
)
1533 ctf_free ((char *) fp
->ctf_strtab
.cts_name
);
1535 else if (fp
->ctf_data_mmapped
)
1536 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1538 ctf_free_base (fp
, NULL
);
1540 if (fp
->ctf_sxlate
!= NULL
)
1541 ctf_free (fp
->ctf_sxlate
);
1543 if (fp
->ctf_txlate
!= NULL
)
1544 ctf_free (fp
->ctf_txlate
);
1546 if (fp
->ctf_ptrtab
!= NULL
)
1547 ctf_free (fp
->ctf_ptrtab
);
1549 ctf_hash_destroy (fp
->ctf_structs
);
1550 ctf_hash_destroy (fp
->ctf_unions
);
1551 ctf_hash_destroy (fp
->ctf_enums
);
1552 ctf_hash_destroy (fp
->ctf_names
);
1557 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1558 archive, so closing one is just like closing an archive. */
1560 ctf_close (ctf_archive_t
*arc
)
1562 ctf_arc_close (arc
);
1565 /* Get the CTF archive from which this ctf_file_t is derived. */
1567 ctf_get_arc (const ctf_file_t
*fp
)
1569 return fp
->ctf_archive
;
1572 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1573 ctfsect's data * after ctf_file_close(), which is why we return the actual
1574 structure, not a pointer to it, since that is likely to become a pointer to
1575 freed data before the return value is used under the expected use case of
1576 ctf_getsect()/ ctf_file_close()/free(). */
1578 ctf_getdatasect (const ctf_file_t
*fp
)
1580 return fp
->ctf_data
;
1583 /* Return the CTF handle for the parent CTF container, if one exists.
1584 Otherwise return NULL to indicate this container has no imported parent. */
1586 ctf_parent_file (ctf_file_t
*fp
)
1588 return fp
->ctf_parent
;
1591 /* Return the name of the parent CTF container, if one exists. Otherwise
1592 return NULL to indicate this container is a root container. */
1594 ctf_parent_name (ctf_file_t
*fp
)
1596 return fp
->ctf_parname
;
1599 /* Set the parent name. It is an error to call this routine without calling
1600 ctf_import() at some point. */
1602 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1604 if (fp
->ctf_dynparname
!= NULL
)
1605 ctf_free (fp
->ctf_dynparname
);
1607 fp
->ctf_dynparname
= ctf_strdup (name
);
1608 fp
->ctf_parname
= fp
->ctf_dynparname
;
1611 /* Import the types from the specified parent container by storing a pointer
1612 to it in ctf_parent and incrementing its reference count. Only one parent
1613 is allowed: if a parent already exists, it is replaced by the new parent. */
1615 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1617 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1618 return (ctf_set_errno (fp
, EINVAL
));
1620 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1621 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1623 if (fp
->ctf_parent
!= NULL
)
1624 ctf_file_close (fp
->ctf_parent
);
1628 fp
->ctf_flags
|= LCTF_CHILD
;
1631 if (fp
->ctf_parname
== NULL
)
1632 ctf_parent_name_set (fp
, "PARENT");
1634 fp
->ctf_parent
= pfp
;
1638 /* Set the data model constant for the CTF container. */
1640 ctf_setmodel (ctf_file_t
*fp
, int model
)
1642 const ctf_dmodel_t
*dp
;
1644 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1646 if (dp
->ctd_code
== model
)
1648 fp
->ctf_dmodel
= dp
;
1653 return (ctf_set_errno (fp
, EINVAL
));
1656 /* Return the data model constant for the CTF container. */
1658 ctf_getmodel (ctf_file_t
*fp
)
1660 return fp
->ctf_dmodel
->ctd_code
;
1663 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1666 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1668 fp
->ctf_specific
= data
;
1671 /* Retrieve the arbitrary pointer again. */
1673 ctf_getspecific (ctf_file_t
*fp
)
1675 return fp
->ctf_specific
;